保证多线程顺序执行，四种方案，你知道几种？

今天药忘吃喽~ 2022-10-11 03:47 121阅读 0赞

本篇是1000期面试系列文章的第94期，持续更新中.....

回复“面试”获取优质面试资源！

## 故事 ##

上周一位同学在面试中遇到了这么一道问题：

> 有三个线程T1、T2、T3，如何保证顺序执行？

常规操作，启动三个线程，让其执行。

public class ThreadDemo {
        public static void main(String[] args) {
    
            final Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程1");
                }
            });
    
            final Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程2");
                }
            });
    
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程3");
                }
            });
            t1.start();
            t2.start();
            t3.start();
        }
    }

运行结果：

线程2
    线程1
    线程3

调用三个线程的start方法，很明显是按照顺序调用的，但是每次运行出来的结果，基本上都不相同，随机性特别强。

怎么办呢？下面我们使用四种方案来实现。

## 方案一 ##

我们可以利用Thread中的join方法解决线程顺序问题，下面我们来简单介绍一下join方法。

官方介绍：

> Waits for this thread to die.

等待这个线程结束，也就是说当前线程等待这个线程结束后再继续执行 。

`join()`方法是`Thread`中的一个`public`方法，它有几个重载版本：

*  `join()`
 *  `join(long millis)`   //参数为毫秒
 *  `join(long millis,int nanoseconds)`  //第一参数为毫秒，第二个参数为纳秒

join()方法实际是利用了`wait()`方法（wait方法是Object中的），只不过它不用等待`notify()/notifyAll()`，且不受其影响。

它结束的条件是：

*  等待时间到
 *  目标线程已经run完（通过`isAlive()`方法来判断）

下面大致看看器源码：

public final void join() throws InterruptedException {
        //调用了另外一个有参数的join方法
        join(0);
    }
    public final synchronized void join(long millis) throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        //0则需要一直等到目标线程run完
        if (millis == 0) {
            // 如果被调用join方法的线程是alive状态，则调用join的方法
            while (isAlive()) {
                // == this.wait(0),注意这里释放的是
                //「被调用」join方法的线程对象的锁
                wait(0);
            }
        } else {
             // 如果目标线程未run完且阻塞时间未到，
            //那么调用线程会一直等待。
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                //每次最多等待delay毫秒时间后继续争抢对象锁，获取锁后继续从这里开始的下一行执行，
                //也可能提前被notify() /notifyAll()唤醒，造成delay未一次性消耗完，
                //会继续执行while继续wait(剩下的delay)
                wait(delay);
                // 这个变量now起的不太好，叫elapsedMillis就容易理解了
                now = System.currentTimeMillis() - base;
            }
       }
    }

下面我们使用join方法来实现线程的顺序执行。

public class ThreadDemo {
        public static void main(String[] args) {
    
            final Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程1");
                }
            });
    
            final Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //等待线程t1执行完成后
                        //本线程t2 再执行
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程2");
                }
            });
    
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //等待线程t2执行完成后
                        //本线程t3 再执行
                        t2.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程3");
                }
            });
            t3.start();
            t2.start();
            t1.start();
        }
    }

运行结果：

线程1
    线程2
    线程3

不管你运行多少次上面这段代码，结果始终不变，所以，我们就解决了多个线程按照顺序执行的问题了。

下面我们来看看另外一种方案：`CountDownLatch`。

## 方案二 ##

我们先来说一下`CountDownLatch`，然后再来使用`CountDownLatch`是怎么解决多个线程顺序执行的。

`CountDownLatch`是一种同步辅助，在AQS基础之上实现的一个并发工具类，让我们多个线程执行任务时，需要等待线程执行完成后，才能执行下面的语句，之前线程操作时是使用 `Thread.join`方法进行等待 。

`CountDownLatch`能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。它相当于是一个计数器，这个计数器的初始值就是线程的数量，每当一个任务完成后，计数器的值就会减一，当计数器的值为 0 时，表示所有的线程都已经任务了，然后在 `CountDownLatch` 上等待的线程就可以恢复执行接下来的任务。

下面我们就用`CountDownLatch`来实现多个线程顺序执行：

import java.util.concurrent.CountDownLatch;
    
    /**
     *  公众号：面试专栏
     * @author 小蒋学
     *  CountDownLatch 实现多个线程顺序执行
     */
    public class ThreadDemo {
        public static void main(String[] args) {
    
            CountDownLatch countDownLatch1 = new CountDownLatch(0);
    
            CountDownLatch countDownLatch2 = new CountDownLatch(1);
    
            CountDownLatch countDownLatch3 = new CountDownLatch(1);
    
    
            Thread t1 = new Thread(new Work(countDownLatch1, countDownLatch2),"线程1");
            Thread t2 = new Thread(new Work(countDownLatch2, countDownLatch3),"线程2");
            Thread t3 = new Thread(new Work(countDownLatch3, countDownLatch3),"线程3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    
        static class Work implements Runnable {
            CountDownLatch cOne;
            CountDownLatch cTwo;
    
            public Work(CountDownLatch cOne, CountDownLatch cTwo) {
                super();
                this.cOne = cOne;
                this.cTwo = cTwo;
            }
    
            @Override
            public void run() {
                try {
                    cOne.await();
                    System.out.println("执行: " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    cTwo.countDown();
                }
            }
        }
    }

运行结果：

执行: 线程1
    执行: 线程2
    执行: 线程3

关于`CountDownLatch`实现多个线程顺序执行就这样实现了，下面我们再用线程池来实现。

## 方案三 ##

在Executors 类中有个单线程池的创建方式，下面我们就用单线程池的方式来实现多个线程顺序执行。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     *  公众号：面试专栏
     * @author 小蒋学
     *  CountDownLatch 实现多个线程顺序执行
     */
    public class ThreadDemo {
        public static void main(String[] args) {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程1");
                }
            },"线程1");
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程2");
                }
            },"线程2");
    
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程3");
                }
            });
    
            ExecutorService executor = Executors.newSingleThreadExecutor();
            // 将线程依次加入到线程池中
            executor.submit(t1);
            executor.submit(t2);
            executor.submit(t3);
            // 及时将线程池关闭
            executor.shutdown();
        }
    }

运行结果：

线程1
    线程2
    线程3

这样我们利用`单线程池`也实现了多个线程顺序执行的问题。下面再来说一种更牛的方案。

## 方案四 ##

最后一种方案是使用`CompletableFuture`来实现多个线程顺序执行。

在Java 8问世前想要实现任务的回调，一般有以下两种方式：

*  借助`Future isDone`轮询以判断任务是否执行结束，并获取结果。
 *  借助`Guava`类库`ListenableFuture`、`FutureCallback`。（netty也有类似的实现）

Java 8 `CompletableFuture`弥补了Java在异步编程方面的弱势。

> 在Java中异步编程，不一定非要使用rxJava，Java本身的库中的`CompletableFuture`可以很好的应对大部分的场景。

`Java8`新增的`CompletableFuture`则借鉴了Netty等对Future的改造，简化了异步编程的复杂性，并且提供了函数式编程的能力 。

使用`Future`获得异步执行结果时，要么调用阻塞方法`get()`，要么轮询看`isDone()`是否为`true`，这两种方法都不是很好，因为主线程也会被迫等待。

从Java 8开始引入了`CompletableFuture`，它针对`Future`做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

接下来我们就使用`CompletableFuture`来实现多个线程顺序执行。

import java.util.concurrent.CompletableFuture;
    
    /**
     *  公众号：面试专栏
     * @author 小蒋学
     *  CountDownLatch 实现多个线程顺序执行
     */
    public class ThreadDemo {
        public static void main(String[] args)  {
            Thread t1 = new Thread(new Work(),"线程1");
            Thread t2 = new Thread(new Work(),"线程2");
            Thread t3 = new Thread(new Work(),"线程3");
    
            CompletableFuture.runAsync(()-> t1.start())
                    .thenRun(()->t2.start())
                    .thenRun(()->t3.start());
        }
    
        static class Work implements Runnable{
            @Override
            public void run() {
                System.out.println("执行 : " + Thread.currentThread().getName());
            }
        }
    }

运行结果：

执行 : 线程1
    执行 : 线程2
    执行 : 线程3

到此，我们就使用`CompletableFuture`实现了多个线程顺序执行的问题。

## 总结 ##

关于多个线程顺序执行，不管是对于面试，还是工作，关于多线程顺序执行的解决方案都是非常有必要掌握的。也希望下次面试官再问：多线程顺序执行问题的时候，你的表情应该是这样的：

![c6b11ff85af12cdd148a6e873efa485f.png][]

好了，今天就分享到这里，如果觉得喜欢，那就在右下角里点**赞**、点**在看**。

往期推荐

[面试官：为什么 SpringBoot 的 jar 可以直接运行？][SpringBoot _ jar]

[面试官：MySQL 批量插入，如何不插入重复数据？][MySQL]

[面试官：java for循环，你知道几种写法？][java for]

[面试官：为什么mysql不建议执行超过3表以上的多表关联查询？][mysql_3]

[面试官：Java遍历Map集合有哪几种方式？各自效率如何？][Java_Map]

[c6b11ff85af12cdd148a6e873efa485f.png]: /images/20221005/6d24efd1099b4430b0483be5f6ae635c.png
[SpringBoot _ jar]: http://mp.weixin.qq.com/s?__biz=MzI1MTYxNTE0Ng%3D%3D&chksm=e9f109c4de8680d2e5d0b8880e77c7533de47d8fa259cc7030cf609995b403ed1f4370900332&idx=1&mid=2247486209&scene=21&sn=7d653d35a6effc0fcacca8bc552cf0a1#wechat_redirect
[MySQL]: http://mp.weixin.qq.com/s?__biz=MzI1MTYxNTE0Ng%3D%3D&chksm=e9f109c5de8680d3a9228cd3bbf98623888abdd43bd14931a928a95dc07dc3b1179102b17fd9&idx=1&mid=2247486208&scene=21&sn=8882627ace826d7d36f1ea22d7b1d9eb#wechat_redirect
[java for]: http://mp.weixin.qq.com/s?__biz=MzI1MTYxNTE0Ng%3D%3D&chksm=e9f10819de86810f89df6346494eba25ca1381d6bb6f94635fb51bbebea599efe73bdbfa5782&idx=1&mid=2247486172&scene=21&sn=dc8e178c5629934f32fc67fd56dae535#wechat_redirect
[mysql_3]: http://mp.weixin.qq.com/s?__biz=MzI1MTYxNTE0Ng%3D%3D&chksm=e9f1081ede86810802827c625c0deeef4247e12ed6670c88a12e3771c115633629595fbaca52&idx=1&mid=2247486171&scene=21&sn=b4777b80aa4644059e867ef8db98ca82#wechat_redirect
[Java_Map]: http://mp.weixin.qq.com/s?__biz=MzI1MTYxNTE0Ng%3D%3D&chksm=e9f10877de868161c3b884149a2e8abbaf737df0bf85ce7995cf5da297ae575d0a0c0b301a93&idx=1&mid=2247486130&scene=21&sn=74b5a1bdb833a5bbdd86d964ab3e9981#wechat_redirect