一文搞懂Java线程的创建方式

川长思鸟来 2023-09-24 22:14 52阅读 0赞

## 前言 ##

本篇文章将对**Java**中的线程创建进行实战说明。

## 正文 ##

### 一. 继承Thread ###

可以通过创建**Thread**的子类并在子类中重写**run()** 方法完成线程创建。示例如下所示。

public class ThreadTest {
    
        @Test
        public void 继承Thread() throws Exception {
            // 创建线程对象
            MyThread myThread = new MyThread();
    
            // 启动线程
            myThread.start();
    
            // 睡1秒，等待子线程执行完任务
            Thread.sleep(1000);
        }
    
        private static class MyThread extends Thread {
            @Override
            public void run() {
                System.out.println("线程执行了");
            }
        }
    
    }
    复制代码

运行测试程序，打印如下。

![format_png][]

其实可以只继承**Thread**，而不重写**run()** 方法，此时是不会报错的，只不过调用**start()** 方法后线程不会执行任何逻辑。示例如下。

public class ThreadTest {
    
        @Test
        public void 继承Thread时可以不重写run方法() {
            // 创建没有重写run()方法的线程对象
            MyThreadNotOverrideRun myThread = new MyThreadNotOverrideRun();
    
            // 启动线程，不报错，执行的是Thread的run()方法，无任何逻辑
            myThread.start();
        }
    
        private static class MyThreadNotOverrideRun extends Thread {}
    
    }
    复制代码

### 二. 创建Runnable对象 ###

可以通过创建**Runnable**接口的实现类，然后将**Runnable**对象作为**Thread**对象的执行任务，来创建线程。示例如下。

public class ThreadTest {
    
        @Test
        public void 基于Runnable() throws Exception {
            // 创建Runnable任务对象
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("任务执行");
                }
            };
    
            // 创建Thread对象时将Runnable任务对象通过构造函数传入
            Thread thread = new Thread(runnable);
    
            // 启动线程
            thread.start();
    
            // 睡1秒，等待子线程执行完任务
            Thread.sleep(1000);
        }
    
    }
    复制代码

运行测试程序，执行结果如下所示。

![format_png 1][]

### 三. 创建Callable对象 ###

**Callable**接口也是可以作为任务被线程执行，其与**Runnable**接口的区别在于**Callable**任务可以有返回值，而**Runnable**任务没有返回值。

由于**Thread**对象只能执行**Runnable**任务，因此无法直接让**Thread**执行**Callable**任务，但是可以先将**Callable**封装成**FutureTask**，而**FutureTask**是实现了**Runnable**接口的，所以**Thread**对象可以执行**FutureTask**任务。示例如下。

public class ThreadTest {
    
        @Test
        public void 基于Callable() throws Exception {
            // 创建Callable任务对象
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    return "任务执行结果";
                }
            };
    
            // 将Callable封装成FutureTask
            FutureTask<String> futureTask = new FutureTask<>(callable);
    
            // 创建Thread对象时将FutureTask通过构造函数传入
            Thread thread = new Thread(futureTask);
    
            // 启动线程
            thread.start();
    
            // 通过FutureTask拿到执行结果
            System.out.println(futureTask.get());
        }
    
    }
    复制代码

运行测试程序，结果如下。

![format_png 2][]

### 四. 基于Runnable创建FutureTask ###

在第三小节中是基于**Callable**来创建的**FutureTask**，本小节将基于**Runnable**来创建**FutureTask**。在此之前，先看一下**FutureTask**的类图，如下所示。

![format_png 3][]

所以**FutureTask**即能够作为**Runnable**被执行，也能够作为**Future**获取异步执行的结果。**FutureTask**有两个构造函数，签名如下。

// 基于Callable创建FutureTask
    public FutureTask(Callable<V> callable)
    
    // 基于Runnable创建FutureTask
    public FutureTask(Runnable runnable, V result)
    复制代码

下面重点看一下如何基于**Runnable**创建**FutureTask**，源码如下所示。

public FutureTask(Runnable runnable, V result) {
        // 使用Executors工具类将Runnable封装成Callable
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;
    }
    复制代码

继续看**Executors\#callable(java.lang.Runnable, T)** 方法，如下所示。

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null) {
            throw new NullPointerException();
        }
        // 将Runnable封装成RunnableAdapter
        return new RunnableAdapter<T>(task, result);
    }
    复制代码

那么**Executors\#callable(java.lang.Runnable, T)** 方法中就是将**Runnable**封装成了**RunnableAdapter**，最后再看一下**RunnableAdapter**的实现。

static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        
        public T call() {
            // 执行Runnable的逻辑
            task.run();
            // 执行完毕后，result作为结果返回
            return result;
        }
    }
    复制代码

**所以这里可以知道，基于`Runnable`创建`FutureTask`，其本质是将`Runnable`先封装为`Callable`，然后再将`Callable`封装成`FutureTask`。还有一点需要注意，在基于`Runnable`创建`FutureTask`时，除了传入`Runnable`，还可以传入一个作为返回结果的对象，`Runnable`执行完毕后，会将这个对象返回，这个对象也可以传一个null，表示不需要返回值。**

基于**Runnable**创建**FutureTask**的一个示例如下。

public class ThreadTest {
    
        @Test
        public void 基于Runnable来构建FutureTask() throws Exception {
            // 创建结果对象
            MyResult myResult = new MyResult();
            // 创建Runnable任务对象
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    myResult.setResult("任务执行");
                }
            };
    
            // 将Runnable封装成FutureTask
            // Runnable执行后，会改变MyResult对象
            FutureTask<MyResult> futureTask = new FutureTask<>(runnable, myResult);
    
            // 创建Thread对象时将FutureTask通过构造函数传入
            Thread thread = new Thread(futureTask);
    
            // 启动线程
            thread.start();
    
            // 通过FutureTask拿到执行结果
            System.out.println(futureTask.get().getResult());
        }
    
        private static class MyResult {
            String result;
    
            public MyResult() {}
    
            public MyResult(String result) {
                this.result = result;
            }
    
            public String getResult() {
                return result;
            }
    
            public void setResult(String result) {
                this.result = result;
            }
        }
    
    }
    复制代码

运行测试程序，结果如下所示。

![format_png 4][]

## 总结 ##

线程的创建，总的概括有三种方式。

1.  **继承`Thread`并重写`run()`方法**；
2.  **创建`Thread`并执行`Runnable`任务**；
3.  **创建`Thread`并执行`Callable`任务**。

[format_png]: https://img-blog.csdnimg.cn/img_convert/0bb066a44d5fd26477252cf9615d9bfc.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/1269583a6fb7ded30ac6e70cc142a8d8.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/4ee6a39a50bf52c812869d2a841f04bc.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/65485faa41167c61f38e6be6e04b7df9.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/b1ef797bbd8af6a668a679e6ee2d433e.webp?x-oss-process=image/format,png