多线程-线程间通讯- CountDownLatch & Cycl

CountDownLatch ：

1. javadoc

   A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
   
   一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行
   

2. code

   /**
    * @Author: GoldHuang
    * @Description: 模拟多个运动员准备参与百米赛跑。
    */
   public class ThreadTest {
   
       /**
        * 模拟运动员1号 起跑线位置准备
        */
       public static void athlete1Preparation() {
           System.out.println("运动员1号 起跑线位置准备 准备完成。");
           System.out.println("运动员1号 位置准备好后 心里准备中。。。 小紧张");
       }
   
       /**
        * 模拟运动员2号 起跑线位置准备
        */
       public static void athlete2Preparation() {
           System.out.println("运动员2号 起跑线位置准备 准备完成。");
           System.out.println("运动员2号 位置准备好后 心里准备中。。。 清风云淡");
       }
   
       /**
        * 模拟运动员3号 起跑线位置准备
        */
       public static void athlete3Preparation() {
           System.out.println("运动员3号 起跑线位置准备 准备完成。");
           System.out.println("运动员3号 位置准备好后 心里准备中。。。 吓尿了");
       }
   
       /**
        * 全部运动员都在起跑线位置 开始比赛
        */
       public static void gameStart() {
           System.out.println("开始比赛， boom!!!");
       }
   
       private static CountDownLatch latch = new CountDownLatch(3);
   
       public static void main(String[] args) throws InterruptedException {
           // 运动员1号
           new Thread(() -> {
               athlete1Preparation();
               latch.countDown();
           }).start();
   
           // 运动员2号
           new Thread(() -> {
               athlete2Preparation();
               latch.countDown();
           }).start();
   
           // 运动员3号
           new Thread(() -> {
               athlete3Preparation();
               latch.countDown();
           }).start();
   
           // 等待所有运动员 起跑线位置准备 
           latch.await();
   
           // 全部运动员准备好 开始比赛
           gameStart();
       }
   }
   
   

   运行结果如图:

   
   countDownLatch-运动员赛跑.png

3. 代码解释

   ​ 3个运动员，每个运动员相当于一个线程，整个比赛相当于一个线程，只有当三个运动员准备好，在起跑线就位，比赛才能开始。

   ​ 侧重点在于比赛的开始，比赛线程的继续。并且比赛的开始，只要需要运动员在起跑线准备好，并不能阻止运动员的心里准备。

   ​ 总结：比赛线程会阻塞，三个运动员准备线程不会阻塞。

CyclicBarrier：

1. javadoc

    A synchronization aid that allows a set of threads to all wait for
    each other to reach a common barrier point.  CyclicBarriers are
    useful in programs involving a fixed sized party of threads that
    must occasionally wait for each other. The barrier is called
    <em>cyclic</em> because it can be re-used after the waiting threads
    are released.
   
   多个线程互相等待，直到到达同一个同步点，再继续一起执行。
   

2. code

   /**
    * @Author: GoldHuang
    * @Description: 模拟多个基友，协作完成任务。
    */
   public class ThreadTestCyclic {
   
       /**
        * 基友1号
        */
       public static void git1(){
           try {
               System.out.println("基友1号 开始做事情...");
               System.out.println("基友1号 做完等待...");
               latch.await();
               System.out.println("基友1号 继续。。。。。");
           }catch (Exception e) {
   
           }
       }
   
       /**
        * 基友2号
        */
       public static void git2(){
           try {
               System.out.println("基友2号 开始做事情...");
               System.out.println("基友2号 做完等待...");
               latch.await();
               System.out.println("基友2号 继续。。。。。");
           } catch (InterruptedException e) {
               e.printStackTrace();
           } catch (BrokenBarrierException e) {
               e.printStackTrace();
           }
       }
   
       /**
        * 基友3号 喜欢偷懒 但是只有他做完他的部分其他两个人才能继续往下做
        */
       public static void git3() {
           try {
               System.out.println("基友3号 开始");
               // 偷懒睡觉1秒
               Thread.sleep(1000);
               System.out.println("----------------基友3号 睡觉完成");
               latch.await();
               System.out.println("基友3号 继续。。。。。");
           } catch (InterruptedException e) {
               e.printStackTrace();
           } catch (BrokenBarrierException e) {
               e.printStackTrace();
           }
   
       }
   
       private static CyclicBarrier latch = new CyclicBarrier(3);
   
       public static void main(String[] args) throws Exception {
           // 1号
           new Thread(() -> {
               git1();
   
           }).start();
   
           // 2号
           new Thread(() -> {
               git2();
           }).start();
   
           // 3号
           new Thread(() -> {
               git3();
           }).start();
   
       }
   }
   

运行结果如图：

3. 代码解释

   ​ 三个基友共同做一件事情，但是基友3手中的部分是关键部分，必须等他做完手中的部分，基友1和基友2才能继续做。

   ​ 所有当基友1和基友2做完时，如果基友三没有做完，那必须等待，直到基友3做完，他们才各自继续往下做事情。