阅读全文

⭐⭐⭐ Spring Boot 项目实战	⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》	《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》	《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》	《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》	《Java 面试题 + Java 学习指南》

摘要: 原创出处 blog.csdn.net/jqc874789596/article/details/100557300 「Jqcode」欢迎转载，保留摘要，谢谢！

• 在子线程中通过join（）方法指定顺序
• 在主线程中通过join（）方法指定顺序
• 通过倒数计时器CountDownLatch实现
• 通过创建单一化线程池newSingleThreadExecutor（）实现

---

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。
5. 认真的源码交流微信群。

---

文章介绍4种方法，简单易懂，通过4个demo抛砖引玉。

在子线程中通过join()方法指定顺序

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

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

public class ThreadJoinDemo {
  public static void main(String[] args) throws InterruptedException {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("打开冰箱！");
      }
    });

    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          thread1.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("拿出一瓶牛奶！");
      }
    });

    final Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          thread2.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("关上冰箱！");
      }
    });

    //下面三行代码顺序可随意调整，程序运行结果不受影响，因为我们在子线程中通过“join()方法”已经指定了运行顺序。
    thread3.start();
    thread2.start();
    thread1.start();

  }
}

运行结果：

打开冰箱！
        拿出一瓶牛奶！
        关上冰箱！

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

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

public class ThreadMainJoinDemo {
  public static void main(String[] args) throws InterruptedException {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("打开冰箱！");
      }
    });

    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("拿出一瓶牛奶！");
      }
    });

    final Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("关上冰箱！");
      }
    });

    thread1.start();
    thread1.join();
    thread2.start();
    thread2.join();
    thread3.start();
  }
}

输出结果：

打开冰箱！
        拿出一瓶牛奶！
        关上冰箱！

通过倒数计时器CountDownLatch实现

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

public class ThreadCountDownLatchDemo {

  private static CountDownLatch countDownLatch1 = new CountDownLatch(1);

  private static CountDownLatch countDownLatch2 = new CountDownLatch(1);

  public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("打开冰箱！");
        countDownLatch1.countDown();
      }
    });

    final Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          countDownLatch1.await();
          System.out.println("拿出一瓶牛奶！");
          countDownLatch2.countDown();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    });

    final Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          countDownLatch2.await();
          System.out.println("关上冰箱！");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    });

    //下面三行代码顺序可随意调整，程序运行结果不受影响
    thread3.start();
    thread1.start();
    thread2.start();
  }
}

输出结果：

打开冰箱！
        拿出一瓶牛奶！
        关上冰箱！

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

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

public class ThreadPoolDemo {

  static ExecutorService executorService = Executors.newSingleThreadExecutor();

  public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("打开冰箱！");
      }
    });

    final Thread thread2 =new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("拿出一瓶牛奶！");
      }
    });

    final Thread thread3 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("关上冰箱！");
      }
    });
    executorService.submit(thread1);
    executorService.submit(thread2);
    executorService.submit(thread3);
    executorService.shutdown();        //使用完毕记得关闭线程池
  }

}

输出结果：

打开冰箱！
        拿出一瓶牛奶！
        关上冰箱！