多线程顺序运行的 4 种方法，面试随便问！

文章介绍4种方法，简单易懂，通过4个demo抛砖引玉。
1、在子线程中通过join()方法指定顺序

通过join()方法使当前线程“阻塞”，等待指定线程执行完毕后继续执行。

举例：在线程thread2中，加上一句thread1.join()，其意义在于，当前线程2运行到此行代码时会进入阻塞状态，直到线程thread1执行完毕后，线程thread2才会继续运行，这就保证了线程thread1与线程thread2的运行顺序。

1. public class ThreadJoinDemo {
2.     public static void main(String[] args) throws InterruptedException {
3.         final Thread thread1 = new Thread(new Runnable() {
4.             @Override
5.             public void run() {
6.                 System.out.println("打开冰箱！");
7.             }
8.         });
10.         final Thread thread2 = new Thread(new Runnable() {
11.             @Override
12.             public void run() {
13.                 try {
14.                     thread1.join();
15.                 } catch (InterruptedException e) {
16.                     e.printStackTrace();
17.                 }
18.                 System.out.println("拿出一瓶牛奶！");
19.             }
20.         });
22.         final Thread thread3 = new Thread(new Runnable() {
23.             @Override
24.             public void run() {
25.                 try {
26.                     thread2.join();
27.                 } catch (InterruptedException e) {
28.                     e.printStackTrace();
29.                 }
30.                 System.out.println("关上冰箱！");
31.             }
32.         });
34.         //下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序。
35.         thread3.start();
36.         thread2.start();
37.         thread1.start();
39.     }
40. }

复制代码

运行结果：

1. 打开冰箱！
2. 拿出一瓶牛奶！
3. 关上冰箱！

复制代码

2、在主线程中通过join()方法指定顺序

简单说一下子线程与主线程的区别，子线程指的是发生在Thread内部的代码，主线程指的是发生在main函数中的代码，我们可以在main函数中通过join()方法让主线程阻塞等待以达到指定顺序执行的目的。

1. public class ThreadMainJoinDemo {
2.     public static void main(String[] args) throws InterruptedException {
3.         final Thread thread1 = new Thread(new Runnable() {
4.             @Override
5.             public void run() {
6.                 System.out.println("打开冰箱！");
7.             }
8.         });
10.         final Thread thread2 = new Thread(new Runnable() {
11.             @Override
12.             public void run() {
13.                 System.out.println("拿出一瓶牛奶！");
14.             }
15.         });
17.         final Thread thread3 = new Thread(new Runnable() {
18.             @Override
19.             public void run() {
20.                 System.out.println("关上冰箱！");
21.             }
22.         });
24.         thread1.start();
25.         thread1.join();
26.         thread2.start();
27.         thread2.join();
28.         thread3.start();
29.     }
30. }

复制代码

基础就不介绍了，多线程系列我博客教程写了很多了，这里推荐大家看看吧：https://www.javastack.cn/categories/Java/
输出结果：

1. 打开冰箱！
2. 拿出一瓶牛奶！
3. 关上冰箱！

复制代码

3、通过倒数计时器CountDownLatch实现

CountDownLatch通过计数器提供了更灵活的控制，只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。

1. public class ThreadCountDownLatchDemo {
3.     private static CountDownLatch countDownLatch1 = new CountDownLatch(1);
5.     private static CountDownLatch countDownLatch2 = new CountDownLatch(1);
7.     public static void main(String[] args) {
8.         final Thread thread1 = new Thread(new Runnable() {
9.             @Override
10.             public void run() {
11.                 System.out.println("打开冰箱！");
12.                 countDownLatch1.countDown();
13.             }
14.         });
16.         final Thread thread2 = new Thread(new Runnable() {
17.             @Override
18.             public void run() {
19.                 try {
20.                     countDownLatch1.await();
21.                     System.out.println("拿出一瓶牛奶！");
22.                     countDownLatch2.countDown();
23.                 } catch (InterruptedException e) {
24.                     e.printStackTrace();
25.                 }
26.             }
27.         });
29.         final Thread thread3 = new Thread(new Runnable() {
30.             @Override
31.             public void run() {
32.                 try {
33.                     countDownLatch2.await();
34.                     System.out.println("关上冰箱！");
35.                 } catch (InterruptedException e) {
36.                     e.printStackTrace();
37.                 }
38.             }
39.         });
41.         //下面三行代码顺序可随意调整，程序运行结果不受影响
42.         thread3.start();
43.         thread1.start();
44.         thread2.start();
45.     }
46. }

复制代码

输出结果：

1. 打开冰箱！
2. 拿出一瓶牛奶！
3. 关上冰箱！

复制代码

4、通过创建单一化线程池newSingleThreadExecutor()实现

单线程化线程池(newSingleThreadExecutor)的优点，串行执行所有任务。

1. public class ThreadPoolDemo {
3.    static ExecutorService executorService = Executors.newSingleThreadExecutor();
5.     public static void main(String[] args) {
6.         final Thread thread1 = new Thread(new Runnable() {
7.             @Override
8.             public void run() {
9.                 System.out.println("打开冰箱！");
10.             }
11.         });
13.         final Thread thread2 =new Thread(new Runnable() {
14.             @Override
15.             public void run() {
16.                 System.out.println("拿出一瓶牛奶！");
17.             }
18.         });
20.         final Thread thread3 = new Thread(new Runnable() {
21.             @Override
22.             public void run() {
23.                 System.out.println("关上冰箱！");
24.             }
25.         });
26.         executorService.submit(thread1);
27.         executorService.submit(thread2);
28.         executorService.submit(thread3);
29.         executorService.shutdown();        //使用完毕记得关闭线程池
30.     }
32. }

复制代码

输出结果：

1. 打开冰箱！
2. 拿出一瓶牛奶！
3. 关上冰箱！

复制代码

来源：blog.csdn.net/jqc874789596/article/details/100557300
近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！