JUC(3)---CountDownLatch、CyclicBarrier和AQS
CountDownLatch可以让一个线程等待其他线程完成了各自的工作之后再执行。比如说一个切菜，一个人切肉，都准备完毕之后才能炒肉。
构造方法：
public CountDownLatch(int count) count等待的线程数量
关键API：
countDown() 分线程执行完减少计数
await() 主线程等待调用
使用：
package com.nijunyang.concurrent; import java.util.concurrent.CountDownLatch; /** * Description: * Created by nijunyang on 2020/5/16 13:53 */ public class CountDownLatchTest{ private CountDownLatch countDownLatch; public CountDownLatchTest(CountDownLatch countDownLatch) { this.countDownLatch = countDownLatch; } public static void main(String[] args) throws InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(2); CountDownLatchTest countDownLatchTest = new CountDownLatchTest(countDownLatch); new Thread(()-> { try { countDownLatchTest.method1(); } catch (InterruptedException e) { e.printStackTrace(); } },"线程1").start(); new Thread(()-> { try { countDownLatchTest.method2(); } catch (InterruptedException e) { e.printStackTrace(); } },"线程2").start(); System.out.println("等待食材准备完毕..."); countDownLatch.await(); System.out.println("炒肉..."); // System.out.println("------第二次使用-----"); // new Thread(()-> { // try { // countDownLatchTest.method1(); // } catch (InterruptedException e) { // e.printStackTrace(); // } // },"线程1").start(); // new Thread(()-> { // try { // countDownLatchTest.method2(); // } catch (InterruptedException e) { // e.printStackTrace(); // } // },"线程2").start(); // // System.out.println("等待食材准备完毕..."); // countDownLatch.await(); // System.out.println("炒肉..."); } private void method1() throws InterruptedException { Thread.sleep(5000L); System.out.println("切菜完毕..."); countDownLatch.countDown(); } private void method2() throws InterruptedException { Thread.sleep(10000L); System.out.println("切肉完毕..."); countDownLatch.countDown(); } }
原理：
1.从构造方法进去我们可以看到又是一个熟悉的Sync内部类继承了AbstractQueuedSynchronizer，入参的数量被赋值到AbstractQueuedSynchronizer的state字段。
2.await方法会去判断state是否等于0，如果不等于0，说明其他线程还没有执行完毕。就会执行doAcquireSharedInterruptibly这个方法，将当前这个调用await方法的线程入队阻塞。
（调用链：await()-sync.acquireSharedInterruptibly-sync.tryAcquireShared-doAcquireSharedInterruptibly）
3.countDown方法，每调一次就会将state的值减1，当扣减到0的时候去唤醒上面等待的主线程执行（调用链：countDown-sync.releaseShared-sync.tryReleaseShared-doReleaseShared（减到0才会执行这方法））
CyclicBarrier：
篱栅，顾名思义有拦截作用。它可以让一组线程到达栅栏时被阻塞，直到最后一个线程到达，才放行通过。比如玩LOL，需要等待所有玩家进度条100%了，才能进入游戏
构造方法：
CyclicBarrier(int parties) parties：阻塞的线程数量
CyclicBarrier(int parties, Runnable barrierAction) parties：阻塞的线程数量 barrierAction：当最后一个线程到达是先执行这个任务，再去执行后面的流程。
关键API：
await() 到达栅栏点等待。调用次数要和入参数量一致，否则会一致阻塞的等待。
使用
package com.nijunyang.concurrent; import java.util.concurrent.CyclicBarrier; /** * @author: create by nijunyang * @date:2019/9/5 */ public class CyclicBarrierTest implements Runnable{ private CyclicBarrier cyclicBarrier; public CyclicBarrierTest(CyclicBarrier cyclicBarrier) { this.cyclicBarrier = cyclicBarrier; } public void run() { try { System.out.println(Thread.currentThread().getName() + "进度条100%... "); cyclicBarrier.await(); } catch (Exception e) { e.printStackTrace(); } } public static void main(String[] args) throws Exception { CyclicBarrier cyclicBarrier = new CyclicBarrier(11, new Runnable() {//11个是因为还有一个主线程也在等待 public void run() { System.out.println("所有人进度条100%，准备开始游戏"); } }); for (int i = 0; i < 10; i++) { new Thread(new CyclicBarrierTest(cyclicBarrier), "线程" + i).start(); } cyclicBarrier.await(); Thread.sleep(300); System.out.println("开始游戏...."); } }
原理：
1.默认每个CyclicBarrier对象有一把锁ReentrantLock和Condition
2.将构造方法的入参数量赋值到count字段中。后续都是在count字段上面进行操作。
3.await的调用会将count的数量-1，如果扣减到0.则会先执行构造方法传入的任务（如果传了），并且重置计数器刷新栅栏，将许可数据重新赋值给count字段（可以重复使用），唤醒条件等待的线程
4.如果扣减完成之后还没有到0.说明还有线程没有到达栅栏点。则进入条件队列阻塞等到，等到最后一个到达时候，才被唤醒
CountDownLatch和CyclicBarrier，最终实现效果看起来都差不多，都是等待分支线程执行完毕，再往下执行。然后CyclicBarrier这个可以重复使用，因为会去刷新count的数量。CountDownLatch不会重新刷新state字段的值。当第二次await执行的时候一看state是0就直接放行了，所以一个CountDownLatch对象只能使用一次。
原理上CountDownLatch是阻塞主线程，分支线线程执行完毕将state扣减到0了之后唤醒主线程去执行，CyclicBarrier则是所有线程到达栅栏点都会阻塞等待。直到后一个到达才唤醒所有的阻塞线程。