java 新建多线程 java创建多线程的方法

Java中创建多线程的方式

1.通过继承Thread类
2.实现Runnable接口
3.实现Collable接口、结合FutureTask类

方式一、继承Thread类
步骤

1、创建一个类MyThread类继承Thread
2、重写Thread类中的run()方法
3、创建线程对象
4、调用start方法来启动多线程

代码演示

public class ThreadTest1 {
    public static void main(String[] args) {

        //3、创建线程对象
        Thread t = new MyThread(); //多态方式创建

        //4、调用start方法启动多线程
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程跑起来"+i);
        }

    }
}

//1、创建一个类去继承Thread类
class MyThread extends Thread{

    //2、重写run()方法

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程跑起来"+i);
        }
    }
}

运行结果

方式二、实现Runnable接口
步骤

1.创建一个接口实现类MyRunnable实现Runnable接口
2.重写Runnable接口中的run方法
3.创建线程任务对象
4.将线程任务对象交给线程执行对象（注意：这里多了一层对象的包包装）
5.线程执行对象调用start方法来启动多线程

代码演示

public class ThreadTest2 {
    public static void main(String[] args) {

        //3.创建线程任务对象
        Runnable mr = new MyRunnable();  //多态方式创建线程任务对象

        //4.将线程任务对象传给线程执行对象
        //5.线程执行对象调用start启动多线程
        new Thread(mr).start();

        for (int i = 0; i < 10 ; i++) {
            System.out.println("主线程执行结果"+i);
        }
    }
}


//1.定义实现类MyRunnable类去实现Runnable接口
class MyRunnable implements Runnable{

    //2.重写Runnable接口中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println("子线程执行结果"+i);
        }

    }
}

运行结果

方式三、实现Collable接口、结合FutureTask类

步骤

1.得到任务对象
a.定义类实现Callable接口，重写call方法,封装要做的事情
b.用FutureTask把Callable对象封装成线程任务对象
2.把线程任务对象交给Thread处理
3.调用Thread的start方法启动线程，执行任务
4.线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果

代码演示

public class ThreadTest3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //3.创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        //4.把Callable任务对象 交给 FutureTask对象
        //FutureTask对象作用1：是Runnable的对象（实现了Runnable接口），可以交给Thread
        //FutureTask对象作用2：可以在线程执行完毕之后 通过调用get方法得到线程的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.交给线程处理
        Thread t1 = new Thread(f1);
        //6.启动线程
        t1.start();


        Callable<String> call1 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call1);
        Thread t2 = new Thread(f2);
        t2.start();

        //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果
        String s = f1.get();
        System.out.println("线程1结果："+s);

        //如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果
        String s1 = f2.get();
        System.out.println("线程2结果："+s1);

    }
}

/*
    1.定义一个任务类 实现Callable接口 应该声明线程任务执行结束后的结果的数据类型
 */
class MyCallable implements Callable<String>{
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写call方法(线程的任务方法)
    @Override
    public String call() throws Exception {
        int sum = 0;

        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是" + sum;
    }
}

运行结果

三种方式的优缺点对比