三种线程创建的方式

本篇内容为线程专题 -- 线程的创建，状态，工作过程中的线程创建方式的部分内容。

JAVA中有三种线程创建的方式：

（1）实现Runnable接口的run方法。

（2）继承Thread类并重写run的方法。

（3）使用FutureTask方式(实现Callable接口的方式)。

说明：在《Java并发编程之美》书中第（3）种创建方式描述为：使用FutureTask方式。

 继承Thread类的方式的实现

/**
 * 创建线程方式--继承Thread类的方式的实现
 * @author JustJavaIt
 */
public class ThreadTest {

    public static void main(String[] args) {
        //创建线程
        MyThread thread = new MyThread();
        //启动线程
        thread.start();
        System.out.println("I am main thread");
    }

    /**
     * 继承Thread类，并重写run方法
     */
    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }
}

运行结果如下：

　　如上代码中的MyThread类继承了Thread类，并重写了run()方法。在main函数里面创建了一个MyThread的实例，然后调用该实例的start方法启动了线程。需要注意的是, 当创建完thread对象后该线程并没有被启动执行，直到调用了start方法后才真正启动了线程。

　　其实调用start方法后线程并没有马上执行而是处于就绪状态，这个就绪状态是指该线程已经获取了除CPU资源外的其他资源，等待获取CPU资源后才会真正处于运行状态。 一旦run方法执行完毕，该线程就处于终止状态。

　　使用继承方式的好处是，在run()方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread()方法；不好的地方是Java不支持多继承，如果继承了Thread类, 那么就不能再继承其他类。另外任务与代码没有分离，当多个线程执行一样的任务时需要 多份任务代码，而Runable则没有这个限制。

实现Runnable接口的run方法方式

/**
 * 创建线程方式--实现Runnable接口的run方法。
 * @author JustJavaIt
 * @date 2022/2/12 16:21
 */
public class RunableTest {
    public static void main(String[] args) {
        RunableTask task = new RunableTask();
        //任务和代码分离，当多个线程执行一样任务时不用多份任务代码。
        new Thread(task).start();
        new Thread(task).start();
    }

    public static class RunableTask implements Runnable{

        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }
}

运行结果如下：

如上代码所示，两个线程共用一个task代码逻辑，如果需要，可以给RunableTask添加参数进行任务区分。另外，RunableTask可以继承其他类。但是上面介绍的两种方式都有一个缺点，就是任务没有返回值。

使用FutureTask方式(实现Callable接口的方式)

　　通过实现callable接口的方式，可以创建一个线程，需要重写其中的call方式。启动线程时，需要创建一个Callable的实例，再用FutureTask实例包装它，最终，再包装成Thread实例，调用start()启动，并且，可以通过FutureTask的get方法来获取返回值。

FutureTask介绍

　　在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装，由于FutureTask也是调用了Runnable接口所以它可以提交给Executor来执行。

/**
 * 创建线程方式--使用FutureTask方式 Page21
 * @author JustJavaIt
 */
public class FutureTasktest {
    public static void main(String[] args) {
        CallerTask callerTask = new CallerTask();
        //创建异步任务
        FutureTask<String> futureTask = new FutureTask<>(callerTask);
        //启动线程
        new Thread(futureTask).start();
        String result;
        try {
            //等待任务执行完毕，并返回结果。
            result = futureTask.get();
            System.out.println("result:"+ result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建任务类，类似Runable
     */
    public static class CallerTask implements Callable<String>{

        @Override
        public String call() throws Exception {
            return "hello";
        }
    }
}

运行结果如下：

　　如上代码中的CallerTask类实现了Callable接口的call()方法。在main函数内首先创建了一个FutrueTask对象(构造函数为CallerTask的实例)，然后使用创建的FutrueTask对象作为任务创建了一个线程并且启动它，最后通过futureTask.get()等待任务执行完毕并返回结果。

　　小结：使用继承方式的好处是方便传参，你可以在子类里面添加成员变量，通过set方法设置参数或者通过构造函数进行传递，而如果使用Runnable方式，则只能使用主线程里面被声明为final的变量。不好的地方是Java不支持多继承，如果继承了Thread类, 那么子类不能再继承其他类，而Runable则没有这个限制。前两种方式都没办法拿到任务的返回结果，但是Futuretask方式可以。

补充

FutureTask和Future示例

 FutureTask是Future和Callable的结合体和Callable的结合体

/**
 * FutureTask示例
 * @author JustJavait
 * @date 2022/1/12 18:02
 */
public class CallableFutureTask {
    public static void main(String[] args) {
        //第一种方式 线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        Task1 task1 = new Task1();
        FutureTask<Integer> futureTask = new FutureTask<>(task1);
        executor.submit(futureTask);
        executor.shutdown();

        //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread
       /* Task1 task1 = new Task1();
        FutureTask<Integer> futureTask = new FutureTask<>(task1);
        Thread thread = new Thread(futureTask);
        thread.start();*/

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }
}

class Task1 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

/**
 * Future示例
 * @author JustJavait
 * @date 2022/1/12 17:55
 */
public class CallableFuture {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果" + result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }
}

class Task implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

运行结果都为：

 三种方式的区别？

Java中，类仅支持单继承，如果一个类继承了Thread类，就无法再继承其它类，因此，如果一个类既要继承其它的类，又必须创建为一个线程，就可以使用实现Runable接口的方式。

使用实现Runable接口的方式创建的线程可以处理同一资源，实现资源的共享。

使用实现Callable接口的方式创建的线程，可以获取到线程执行的返回值、是否执行完成等信息。

Java中Runnable和Callable有什么不同？

Runnable和Callable都是创建线程的方式。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。

（1）实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；

（2）Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

 <END>

⭐️希望本文章对您有帮助，您的「 转发、点赞 」是我创作的无限动力。

扫描下方二维码关注微信公众号，您会收到更多优质文章推送。