创建线程的方式实现与对比

拼搏现实的明天。 2023-01-18 12:29 1阅读 0赞

## 线程创建的几种方式 ##

> 在并发编程中，最基本的就是创建线程了，那么一般的创建姿势是怎样的，又都有些什么区别

一般来讲线程创建有四种方式:

1.  继承Thread
2.  实现Runnable接口
3.  实现Callable接口，结合 FutureTask使用
4.  利用该线程池ExecutorService、Callable、Future来实现

所以本篇博文从布局来讲，分为两部分

1.  实例演示四种使用方式
2.  对比分析四种使用方式的异同，以及适合的应用场景

## I. 实例演示 ##

**目标: 创建两个线程并发实现从1-1000的累加**

### 1. 继承Thread实现线程创建 ###

实现逻辑如下

public class AddThread extends Thread {
    
        private int start, end;
    
        private int sum = 0;
    
        public AddThread(String name, int start, int end) {
            super(name);
            this.start = start;
            this.end = end;
        }
        public void run() {
            System.out.println("Thread-" + getName() + " 开始执行!");
            for (int i = start; i <= end; i ++) {
                sum += i;
            }
            System.out.println("Thread-" + getName() + " 执行完毕! sum=" + sum);
        }
    
        public static void main(String[] args) throws InterruptedException {
            int start = 0, mid = 500, end = 1000;
    
            AddThread thread1 = new AddThread("线程1", start, mid);
            AddThread thread2 = new AddThread("线程2", mid + 1, end);
    
            thread1.start();
            thread2.start();
    
            // 确保两个线程执行完毕
            thread1.join();
            thread2.join();
    
            int sum = thread1.sum + thread2.sum;
            System.out.println("ans: " + sum);
        }
    }

输出结果

Thread-线程1 开始执行!
    Thread-线程2 开始执行!
    Thread-线程1 执行完毕! sum=125250
    Thread-线程2 执行完毕! sum=375250
    ans: 500500

一般实现步骤:

*  继承 `Thread` 类
 *  覆盖 `run()` 方法
 *  直接调用 `Thread#start()` 执行

逻辑比较清晰，只需要注意覆盖的是run方法，而不是start方法

### 2. 实现Runnable接口方式创建线程 ###

public class AddRun implements Runnable {
    
        private int start, end;
        private int sum = 0;
    
        public AddRun(int start, int end) {
            this.start = start;
            this.end = end;
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 开始执行!");
            for(int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println(Thread.currentThread().getName() + " 执行完毕! sum=" + sum);
        }
    
    
        public static void main(String[] args) throws InterruptedException {
            int start = 0, mid = 500, end = 1000;
            AddRun run1 = new AddRun(start, mid);
            AddRun run2 = new AddRun(mid + 1, end);
            Thread thread1 = new Thread(run1, "线程1");
            Thread thread2 = new Thread(run2, "线程2");
    
            thread1.start();
            thread2.start();
    
            thread1.join();
            thread2.join();
            int sum = run1.sum + run2.sum;
            System.out.println("ans: " + sum);
        }
    }

输出结果

线程2 开始执行!
    线程1 开始执行!
    线程2 执行完毕! sum=375250
    线程1 执行完毕! sum=125250
    ans: 500500

一般实现步骤:

*  实现`Runnable`接口
 *  获取实现Runnable接口的实例，作为参数，创建Thread实例
 *  执行 `Thread#start()` 启动线程

**说明**

相比于继承Thread，这里是实现一个接口，最终依然是借助 `Thread#start()`来启动线程

**然后就有个疑问：**

两者是否有本质上的区别，在实际项目中如何抉择？

### 3. 实现Callable接口，结合FutureTask创建线程 ###

> Callable接口相比于Runnable接口而言，会有个返回值，那么如何利用这个返回值呢?

demo如下

public class AddCall implements Callable<Integer> {
    
        private int start, end;
    
        public AddCall(int start, int end) {
            this.start = start;
            this.end = end;
        }
    
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            System.out.println(Thread.currentThread().getName() + " 开始执行!");
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println(Thread.currentThread().getName() + " 执行完毕! sum=" + sum);
            return sum;
        }
    
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            int start = 0, mid = 500, end = 1000;
            FutureTask<Integer> future1 = new FutureTask<>(new AddCall(start, mid));
            FutureTask<Integer> future2 = new FutureTask<>(new AddCall(mid + 1, end));
    
            Thread thread1 = new Thread(future1, "线程1");
            Thread thread2 = new Thread(future2, "线程2");
    
            thread1.start();
            thread2.start();
    
            int sum1 = future1.get();
            int sum2 = future2.get();
            System.out.println("ans: " + (sum1 + sum2));
        }
    }

输出结果

线程2 开始执行!
    线程1 开始执行!
    线程2 执行完毕! sum=375250
    线程1 执行完毕! sum=125250
    ans: 500500

一般实现步骤：

*  实现`Callable`接口
 *  以`Callable`的实现类为参数，创建`FutureTask`实例
 *  将`FutureTask`作为Thread的参数，创建Thread实例
 *  通过 `Thread#start` 启动线程
 *  通过 `FutreTask#get()` 阻塞获取线程的返回值

**说明**

Callable接口相比Runnable而言，会有结果返回，因此会由FutrueTask进行封装，以期待获取线程执行后的结果；

最终线程的启动都是依赖`Thread#start`

### 4. 线程池方式创建 ###

demo如下，创建固定大小的线程池，提交Callable任务，利用Future获取返回的值

public class AddPool implements Callable<Integer> {
        private int start, end;
    
        public AddPool(int start, int end) {
            this.start = start;
            this.end = end;
        }
    
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            System.out.println(Thread.currentThread().getName() + " 开始执行!");
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println(Thread.currentThread().getName() + " 执行完毕! sum=" + sum);
            return sum;
        }
    
        public static void main(String[] arg) throws ExecutionException, InterruptedException {
            int start=0, mid=500, end=1000;
            ExecutorService executorService = Executors.newFixedThreadPool(2);
            Future<Integer> future1 = executorService.submit(new AddPool(start, mid));
            Future<Integer> future2 = executorService.submit(new AddPool(mid+1, end));
    
            int sum = future1.get() + future2.get();
            System.out.println("sum: " + sum);
        }
    }

输出结果

pool-1-thread-1 开始执行!
    pool-1-thread-2 开始执行!
    pool-1-thread-1 执行完毕! sum=125250
    pool-1-thread-2 执行完毕! sum=375250
    sum: 500500

一般实现逻辑：

*  创建线程池（可以利用JDK的Executors，也可自己实现）
 *  创建Callable 或 Runnable任务，提交到线程池
 *  通过返回的 `Future#get` 获取返回的结果

## II. 对比分析 ##

### 1. 分类 ###

上面虽然说是有四种方式，但实际而言，主要划分为两类

*  继承Thread类，覆盖run方法填写业务逻辑
 *  实现Callable或Runnable接口，然后通过Thread或线程池来启动线程

此外，还有一种利用Fork/Join框架来实现并发的方式，后续专门说明，此处先略过

### 2. 区分说明 ###

继承和实现接口的区别

> 先把线程池的方式拎出来单独说，这里主要对比Thread, Callable, Runnable三中方式的区别

个人理解，线程的这两种方式的区别也就只有继承和实现接口的本质区别：

一个是继承Thread类，可以直接调用实例的 `start()`方法来启动线程；另一个是实现接口，需要借助 `Thread#start()`来启动线程

继承因为java语言的限制，当你的任务需要继承一个自定义的类时，会有缺陷；而实现接口却没有这个限制

--------------------

至于网上很多地方说的实现Runnable接口更利于资源共享什么的，比如下面这种作为对比的

public class ShareTest {
        private static class MyRun implements Runnable {
            private volatile AtomicInteger ato = new AtomicInteger(5);
            @Override
            public void run() {
                while (true) {
                    int tmp = ato.decrementAndGet();
                    System.out.println(Thread.currentThread() + " : " + tmp);
                    if (tmp <= 0) {
                        break;
                    }
                }
            }
        }
    
    
        public static void main(String[] args) throws InterruptedException {
            MyRun run = new MyRun();
            Thread thread1 = new Thread(run, "线程1");
            Thread thread2 = new Thread(run, "线程2");
    
            thread1.start();
            thread2.start();
    
            thread1.join();
            thread2.join();
            System.out.println("over");
        }
    }

输出结果

Thread[线程1,5,main] : 4
    Thread[线程2,5,main] : 3
    Thread[线程1,5,main] : 2
    Thread[线程2,5,main] : 1
    Thread[线程1,5,main] : 0
    Thread[线程2,5,main] : -1
    over

`MyRun`实现`Runnable`接口，然后创建一个实例，将这个实例作为多个Thread的参数构造Thread类，然后启动线程，发现这几个线程共享了 `MyRun#ato` 变量

然而上面这个实现接口改成继承Thread，其他都不变，也没啥两样

public class ShareTest {
    
        private static class MyRun extends Thread {
            private volatile AtomicInteger ato = new AtomicInteger(5);
            @Override
            public void run() {
                while (true) {
                    int tmp = ato.decrementAndGet();
                    System.out.println(Thread.currentThread() + " : " + tmp);
                    if (tmp <= 0) {
                        break;
                    }
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            MyRun run = new MyRun();
            Thread thread1 = new Thread(run, "线程1");
            Thread thread2 = new Thread(run, "线程2");
    
            thread1.start();
            thread2.start();
    
            thread1.join();
            thread2.join();
            System.out.println("over");
        }
    }

输出如下

Thread[线程1,5,main] : 4
    Thread[线程2,5,main] : 3
    Thread[线程1,5,main] : 2
    Thread[线程1,5,main] : 0
    Thread[线程2,5,main] : 1
    Thread[线程2,5,main] : -1
    over

上面除了说明使用Runnable更利于资源共享神马的，其实并没有之外，还有一个比较有意思的，为什么会输出-1？

如果我这个任务是售票的话，妥妥的就超卖了，这个问题留待后续详解

--------------------

Runnable, Callable两种区别

这两个就比较明显了，最根本的就是

*  Runnable 无返回结果
 *  Callable 有返回结果

从根源出发，就直接导致使用姿势上的区别

举个形象的例子说明两种方式的区别：

小明家今儿没米了，小明要吃饭怎么办？

小明他妈对小明说，去你大爷家吃饭吧，至于小明到底吃没吃着，小妈他妈就不管了，这就是Runnable方式；

小明他妈一想，这一家子都要吃饭，我先炒个菜，让小明去大爷家借点米来，所以就等着小明拿米回来开锅，这就是Callable方式

**1.Runnable**

Runnable不关心返回，所以任务自己默默的执行就可以了，也不用告诉我完成没有，我不care，您自己随便玩，所以一般使用就是

`new Thread(new Runnable() { public void run() {...} }).start()`

换成JDK8的 lambda表达式就更简单了 `new Thread(() -> {}).start();`

**2.Callable**

相比而言，callbale就悲催一点，没法这么随意了，因为要等待返回的结果，但是这个线程的状态我又控制不了，怎么办？借助`FutrueTask`来玩，所以一般可以看到使用方式如下:

FutureTask<Object> future = new FutureTask<>(() -> null);
    new Thread(future).start();
    Object obj = future.get(); // 这里会阻塞，直到线程返回值

--------------------

Thread启动和线程池启动方式

这个就高端了，线程池一听就感觉厉害了，前面的四中方式有三种都是`Thread#start()`来启动线程，这也是我们最常用的方式，这里单独说一下线程池的使用姿势

*  首先是创建一个线程池
 *  利用 `ExecutorService#submit()`提交线程
 *  `Future<Object>` 接收返回

ExecutorService executorService = Executors.newFixedThreadPool(2);
    Future<Integer> future1 = executorService.submit(()-> 10);
    int ans = future1.get();

说明，这里提交线程之后，并不表示线程立马就要执行，也不表示一定可以执行（这个留待后续线程池的学习中探讨）

--------------------

## III. 小结 ##

### 四种创建方式 ###

1.  继承Thread类，覆盖run方法，调用 `Thread#start`启动
2.  实现Runnable接口，创建实例，作为`Thread`构造参数传入，调用 `Thread#start`启动 new Thread(() -> \{\}).start()
3.  实现Callable接口，创建实例，作为`FutureTask<>`构造参数创建`FutureTask`对象，将FutureTask对象作为`Thread`构造参数传入，调用 `Thread#start`启动 FutureTask<Object> future = new FutureTask<>(() -> null); new Thread(future).start(); Object obj = future.get(); // 这里会阻塞，直到线程返回值
4.  创建一个线程池,利用 `ExecutorService#submit()`提交线程,`Future<Object>` 接收返回 ExecutorService executorService = Executors.newFixedThreadPool(2); Future<Integer> future1 = executorService.submit(()-> 10); int ans = future1.get();

### 区别与应用场景 ###

*  继承和实现接口的方式唯一区别就是继承和实现的区别，不存在共享变量的问题
 *  需要获取返回结果时，结合 FutureTask和Callable来实现
 *  Thread和Runnable的两种方式，原则上想怎么用都可以，个人也没啥好推荐的，随意使用
 *  线程池需要注意线程复用时，对ThreadLocal中变量的串用问题（本篇没有涉及，等待后续补上）

### 注意 ###

*  利用线程池创建线程，实际上依然是借助的Runnable或者Callable，能否算一种新的方式纯看个人理解
 *  采用Timer方式实现定时任务的方式，也是一种新的创建线程的方式，这里也没有多说。

![20210506152220421.jpg][]

[20210506152220421.jpg]: /images/20221021/94f2ffdf04194e3bb1cd4d13fd11fd30.png