二十一. 并发实战-线程的创建方式

谁践踏了优雅 2024-03-29 15:59 57阅读 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("线程执行了");
            }
        }
    
    }

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

![在这里插入图片描述][6c2f50795f514399915e1cd44e4fdebb.jpeg_pic_center]

其实可以只继承`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);
        }
    
    }

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

![在这里插入图片描述][5ed373c1b823440e980698f93df0ff10.jpeg_pic_center]

#### 三. 创建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());
        }
    
    }

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

![在这里插入图片描述][311e74343d7441e4b7abe5d6f2b2ab6e.jpeg_pic_center]

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

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

![在这里插入图片描述][98253e1946c848d78840344707daa304.jpeg_pic_center]

所以`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;
            }
        }
    
    }

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

![在这里插入图片描述][e9a652ae10c6430dae36ca332a114cdd.jpeg_pic_center]

### 总结 ###

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

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

[6c2f50795f514399915e1cd44e4fdebb.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/4076ce3b947e4f728c4ada470016451e.png
[5ed373c1b823440e980698f93df0ff10.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/dbc92faa6aba4688a5a799bd993c5286.png
[311e74343d7441e4b7abe5d6f2b2ab6e.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0e6a70bb1e744309b1b1aff7836306b0.png
[98253e1946c848d78840344707daa304.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/b3f254d1ef5f4fb081ba2fa7ecd2367b.png
[e9a652ae10c6430dae36ca332a114cdd.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2eb9b27aa54f4fc49c466766966130a1.png