Java 多线程协调工具 CyclicBarrier 与CountDownLatch 学习

CyclicBarrier

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

/**
 * 文件功能：CyclicBarrier 多线程线程协调辅助工具
 * 故事，一个班5个士兵同时端枪射击
 * Created
 */
public class CyclicBarrierSample {
    static CyclicBarrier cyclBr=new CyclicBarrier(5, new Runnable() {
        @Override
        public void run() {
            System.out.println("听班长口令，开始射击----");
        }
    });
  
    public static void  main(String args[]){
        for(int i=0;i<=4;i++){
          new MyThread2("A班士兵"+i,cyclBr).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("B班开始准备射击（重复使用CyclicBarrier）************");
        for(int i=0;i<=4;i++){
            new MyThread2("B班士兵"+i,cyclBr).start();
        }
    }
}

class MyThread2 extends Thread{
    CyclicBarrier cyclBr;
    public MyThread2(String name,CyclicBarrier cyclBr){
        super(name);
        this.cyclBr=cyclBr;
    }

    public void run()
    {
        System.out.println(Thread.currentThread().getName()+"端枪，准备好..." );
        try {
            cyclBr.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"射击>>>>>>");
    }

}

预期输出：

A班士兵1端枪，准备好...
A班士兵2端枪，准备好...
A班士兵3端枪，准备好...
A班士兵0端枪，准备好...
A班士兵4端枪，准备好...
听班长口令，开始射击----
A班士兵4射击>>>>>>
A班士兵1射击>>>>>>
A班士兵2射击>>>>>>
A班士兵3射击>>>>>>
A班士兵0射击>>>>>>
B班开始准备射击（重复使用CyclicBarrier）************
B班士兵0端枪，准备好...
B班士兵2端枪，准备好...
B班士兵4端枪，准备好...
B班士兵3端枪，准备好...
B班士兵1端枪，准备好...
听班长口令，开始射击----
B班士兵1射击>>>>>>
B班士兵0射击>>>>>>
B班士兵2射击>>>>>>
B班士兵4射击>>>>>>
B班士兵3射击>>>>>>

CountDownLatch

import java.util.Random;
import java.util.concurrent.CountDownLatch;

/**
 * 文件功能：CountDownLatch 多线程计数同步工具
 * Created
 * 故事，一个班里5个兵紧急集合。
 * 模拟 集合时间统计。
 */
public class CountDownLatchSample {

    static CountDownLatch bugleCall=new CountDownLatch(1);//吹响集结号
    static CountDownLatch assemblied=new CountDownLatch(5);//集结完毕

    public static void main(String[] args){
        for(int i=0;i<5;i++){
            new Thread(new Soldier("士兵"+i,bugleCall,assemblied)).start();
            try {
                Thread.sleep(1000);//等1s都睡下了吧
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("班长吹响集结号--------------");
        Long startTime=System.currentTimeMillis();
        bugleCall.countDown();
        try {
            assemblied.await();
            System.out.println("集结完毕，本次集结耗时：【"+(System.currentTimeMillis()-startTime)/1000+"】秒。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


class  Soldier implements  Runnable{
         CountDownLatch listen;//听号声集合
         CountDownLatch report;//集结完毕，报告
         String name;
        public Soldier(String name,CountDownLatch listen,CountDownLatch report){
            this.listen=listen;
            this.name=name;
            this.report=report;
        }

    @Override
    public void run() {
        try {
            System.out.println(this.name + "正在作好梦。。。");
            listen.await();
            System.out.println(this.name + "听到号声，开始起床集合。");
            Thread.sleep(new Random().nextInt(5000));//随机延时5秒引内
            System.out.println(this.name + "集合完毕。");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            report.countDown();
        }

    }
}

预期输出：

士兵0正在作好梦。。。
士兵1正在作好梦。。。
士兵2正在作好梦。。。
士兵3正在作好梦。。。
士兵4正在作好梦。。。
班长吹响集结号--------------
士兵0听到号声，开始起床集合。
士兵3听到号声，开始起床集合。
士兵2听到号声，开始起床集合。
士兵1听到号声，开始起床集合。
士兵4听到号声，开始起床集合。
士兵3集合完毕。
士兵0集合完毕。
士兵4集合完毕。
士兵2集合完毕。
士兵1集合完毕。
集结完毕，本次集结耗时：【2】秒。