阅读全文

《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();        //使用完毕记得关闭线程池
  }

}

输出结果：

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