线程协作，控制并发流程(CountDownLatch,Semaphore,Condition,CyclicBarrier)

线程协作，控制并发流程

控制并发流程的工具类，作用就是帮助我们更容易得让线程之间合作，让线程之间相互配合，来满足业务逻辑

常见并发控制工具类

CountDownLatch 计数器

countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。

是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了

主要方法介绍

CountDownLatch(int count)

只提供了一个构造方法，参数count为需要倒数的数值

await()

调用await()方法的线程将会被挂起，它会等待直到count的值为0才继续执行

countDown()

没调用一次数值减1，直到为0时，等待的线程会被唤醒

代码演示

• 一个线程等待多个线程都执行完毕，在继续自己的工作

public class countDownLatchDemo {


    public static void main(String[] args) throws InterruptedException {
        CountDownLatch downLatch = new CountDownLatch(5);

        ExecutorService service = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            int finalI = i;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep((long)Math.random()*100000);
                        System.out.println("NO  "+ finalI + "检查完成");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        downLatch.countDown();
                    }
                }
            };
            service.submit(runnable);
        }
        System.out.println("等待5个人检查完成");
        downLatch.await();
        System.out.println("检查完成");
    }
}

• 多个线程等待某一个线程的信号，同时开始执行

模拟跑步的场景，5个人等待裁判员的发令枪。只要一声令下，所有人同时开始跑步

public class countDownLatchDemo2 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch downLatch = new CountDownLatch(1);

        ExecutorService service = Executors.newFixedThreadPool(15);

        for (int i = 0; i < 15; i++) {
            int finalI = i;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {

                        System.out.println("NO  "+ finalI + "开始等待发令");
                        downLatch.await();
                        System.out.println("NO  "+ finalI + "开始跑步");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.submit(runnable);

        }
        Thread.sleep(5000);
        System.out.println("发令枪响起，开始跑步");
        downLatch.countDown();
    }
}

模拟跑步的场景，5个人等待裁判员的发令枪。只要一声令下，所有人同时开始跑步. 终点的裁判员等待最后一名运动员到达终点后，宣布运动会结束

public class countDownLatchDemo2 {


    public static void main(String[] args) throws InterruptedException {
        CountDownLatch downLatch = new CountDownLatch(1);
        CountDownLatch downLatch2 = new CountDownLatch(15);
        ExecutorService service = Executors.newFixedThreadPool(15);

        for (int i = 0; i < 15; i++) {
            int finalI = i;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {

                        System.out.println("NO  "+ finalI + "开始等待发令");
                        downLatch.await();
                        System.out.println("NO  "+ finalI + "开始跑步");
                        Thread.sleep((long)Math.random()*10000);
                        downLatch2.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.submit(runnable);

        }

        Thread.sleep(5000);
        System.out.println("发令枪响起，开始跑步");

        downLatch.countDown();

        System.out.println("裁判员等待");
        downLatch2.await();

        System.out.println("最后一名运行员到达，比赛结束");
    }

}

Semaphore 信号量

用来限制和管理优先资源的使用情况

信号量的作用是维护一个"许可证"的计数，线程获取许可证，那许可证的剩余就减一，线程也可以释放一个许可证，那么许可证数量就加一，当信号量拥有的许可证的数量为0时，那么下一个获取许可证的线程将会等待，直到另外的线程释放了许可证

信号量使用流程

• 初始化Semaphore 并指定许可证数量

• 在需要被限制的代码前acquire() 或者acquireUninterruptibly()方法

• 任务结束后，调用release()释放许可证

信号量的重要方法

new Semaphore(int permits,boolean fair)

这里可以设置是否要使用公平策略，如果传入true,那么semaphore会把之前等待的线程放到FIFO的队列里，以便于当有了新的许可证可以分发给之前等了最长时间的线程

acquire()/acquireUninterruptibly()

acquire(int permits)

一次拿到指定数量的许可证

tryAcquire()

看看现在有没有空闲的许可证，如果有的话就获取，如果没有的话没关系，不比陷入阻塞，可以去做别的是事，过会再来查看许可证的空闲情况

tryAcquire(timeout)

和tryAcquire()一样，但是多了一个超时时间，比如“在3秒内获取不到许可证，我就去做别的事”

release()

释放许可证

release(int permits)

释放指定数量的许可证

代码演示

public class SemaphoreDemo {
   static  Semaphore se = new Semaphore(3,true);
   public static void main(String[] args) {


       ExecutorService service = Executors.newFixedThreadPool(50);

       for (int i = 0; i < 100; i++) {

           service.submit(new Task());
       }

       service.shutdown();
   }

   static class Task implements Runnable{


       @Override
       public void run() {
           try {
               se.acquire();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println(Thread.currentThread().getName()+" 拿到许可证");

           try {
               Thread.sleep(2000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println(Thread.currentThread().getName()+" 释放许可证");
           se.release();
       }
   }
}

注意点

• 获取和释放的许可证必须是一致，否则会导致许可证数量不够用，会导致程序卡死

• 并不是必须由获取许可证的线程释放那个许可证，事实上，获取和释放许可证对线程并无要求，也是A获取了，然后由B释放，只要逻辑合理即可。

Condition

当线程1需要等待某个条件的时候，它就去执行condition.await()方法，一旦执行了await()方法，线程就会进入阻塞状态

然后通常会有另外一个线程，去执行对应的条件，直到这个条件达成的时候，调用condition.signal()方法，这是JVM就会从被阻塞的线程栈里面找到被阻塞的线程，当线程1就会收到可执行信号的时候，线程的状态就会变成Runnable可执行状态

主要方法

signalAll()

唤起所有的正在等待的线程

signal()

只唤起等待时间最长的线程

代码演示

基本用法

public class ConditionDemo {

    private ReentrantLock reentrantLock = new ReentrantLock();

    private Condition condition = reentrantLock.newCondition();

    void method1() throws InterruptedException {
        reentrantLock.lock();
        try{
            System.out.println("条件不满足");
            condition.await();
            System.out.println("条件满足，开始执行");
        }finally {
            reentrantLock.unlock();
        }
    }

    void method2() throws InterruptedException {
        reentrantLock.lock();
        try{
            System.out.println("准备工作完成，开始唤醒其他线程");
            condition.signal();
        }finally {
            reentrantLock.unlock();
        }
    }

    public static void main(String[] args) {
        ConditionDemo conditionDemo = new ConditionDemo();

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    conditionDemo.method1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                try {
                    conditionDemo.method2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        new Thread(runnable).start();
        new Thread(runnable1).start();

    }

}

生产者消费者

public class ConditionDemo2 {
 private static Integer queueSize = 10;
 private static PriorityQueue<Integer> queue = new PriorityQueue<>(queueSize);
 private ReentrantLock reentrantLock = new ReentrantLock();

 private Condition notEmpty = reentrantLock.newCondition();
 private Condition notFull = reentrantLock.newCondition();

 public static void main(String[] args) {
     ConditionDemo2 cd = new ConditionDemo2();
     producer producer = cd.new producer();
     consumer cs = cd.new consumer();
     producer.start();
     cs.start();
 }

 class producer extends Thread {

     @Override
     public void run() {
         while(true){

             try {
                 reentrantLock.lock();
                 if(queue.size() == queueSize){
                     System.out.println("队列已满");
                     try {
                         notFull.await();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 queue.offer(1);
                 notEmpty.signal();
             }finally {
                 reentrantLock.unlock();
             }

         }

     }
 }


 class consumer extends Thread {

     @Override
     public void run() {

         while(true){

             try{
                 reentrantLock.lock();
                 if(queue.size() == 0){
                     System.out.println("队列为空");
                     try {
                         notEmpty.await();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 System.out.println(queue.poll());
                 notFull.signal();
             }finally {
                 reentrantLock.unlock();
             }
         }
     }
 }
}

CyclicBarrier

CyclicBarrier循环栅栏和CountDownLatch很类似，都能阻塞一组线程

当有大量线程相互配合，分别计算不同任务，并且需要最后统一汇总的时候，我们可以使用CyclicBarrier。CyclicBarrier可以构造一个集结点，当某一个线程执行完毕，他就会到集结点等待，知道所有线程都到了集结点，那么栅栏就被撤销，所有线程在统一出发，继续执行剩下的任务。

代码演示

public class CyclicBarrierDemo {

    public static void main(String[] args) {
        CyclicBarrier cb = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("人全部都到了");
            }
        });

        for (int i = 0; i < 5; i++) {
            new Thread(new Task(i,cb)).start();
        }
    }

    static class Task implements Runnable{
         private int id;
         private CyclicBarrier cyclicBarrier;

        public Task(int id, CyclicBarrier cyclicBarrier) {
            this.id = id;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("线程 "+id+" "+"前往集合地点");
            try {
                Thread.sleep(5000);
                System.out.println("线程 "+id+" "+"到达集合地点，等到其他人");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}

/**

线程 0 前往集合地点
线程 1 前往集合地点
线程 2 前往集合地点
线程 3 前往集合地点
线程 4 前往集合地点
线程 2 到达集合地点，等到其他人
线程 0 到达集合地点，等到其他人
线程 3 到达集合地点，等到其他人
线程 1 到达集合地点，等到其他人
线程 4 到达集合地点，等到其他人
人全部都到了


*/

CyclicBarrier与CountDownLatch的区别

• 作用不同

  CyclicBarrier要等到固定数量的线程都达到了栅栏位置才能继续执行，而CountDownLatch只需要等待数字到0 。CountDownLatch用于事件，CyclicBarrier用于线程

• 可重用性

  CountDownnLatch在倒数到0并触发门闩打开后，就不能再次使用了，除非新建新的实例，而CyclicBarrier可以重复使用