并发-6-wait、notify、Semaphore、CountDownLatch、CyclicBarrier

wait()、notify()和notifyAll()是Object类中的方法：

为什么wait()等方法是在Object中而不是Thread中呢？

同理，wait(),notify()是对等待这个Object(锁)的线程进行阻塞，唤醒等操作的，当然也要放在Object中

假设，wait(),notify()放在Thead中，那么Thread可能等待很多个锁，操作起来也很复杂

如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）

调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）

同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）

进阶一信号量

Java 提供了经典信号量（Semaphore）的实现，通过控制一定数量的允许（permit）的方式，来达到限制通用资源访问的目的。你可以想象一下这个场景，在车站、机场等出租车时，当很多空出租车就位时，为防止过度拥挤，调度员指挥排队，等待坐车的队伍一次进来5个人上车，等这5个人坐车出发，再放进去下一批当信号量的大小为1时，与synchronized没有区别

public class SemaphoreTest {private static Semaphore semaphore = new Semaphore(5);public static void main(String[] args) {for (int i = 0; i < 10; i++) {new CarWorker(semaphore).start();}}
}class CarWorker extends Thread {private Semaphore semaphore;public CarWorker(Semaphore semaphore) {this.semaphore = semaphore;}@Overridepublic void run() {try {out.println(Thread.currentThread() + " waiting permitted");semaphore.acquire();out.println(Thread.currentThread() + " on car !");Thread.sleep(10000);} catch (Exception e) {} finally {out.println(Thread.currentThread() + " release permitted");semaphore.release();}}
}
复制代码

进阶-CountDownLatch

一次性使用的计数器，当CountDownLatch中数值为0时，所有await的线程得到唤醒特别适合于A线程需要等待B和C线程的结果作为参数的这种场景

public class CountDownLatchTest {public static void main(String[] args) {CountDownLatch countDownLatch = new CountDownLatch(6);for (int i = 0; i < 5; i++) {new FirstBatchPassenger(countDownLatch).start();}for (int i = 0; i < 5; i++) {new SecondBatchPassenger(countDownLatch).start();}while (countDownLatch.getCount() != 1) {try {Thread.sleep(1000);} catch (InterruptedException e) {}}out.println("MainThread countDown!");countDownLatch.countDown();}
}class FirstBatchPassenger extends Thread {private CountDownLatch countDownLatch;public FirstBatchPassenger(CountDownLatch countDownLatch) {this.countDownLatch = countDownLatch;}@Overridepublic void run() {out.println("FirstBatchPassenger Executed!");countDownLatch.countDown();}
}class SecondBatchPassenger extends Thread {private CountDownLatch countDownLatch;public SecondBatchPassenger(CountDownLatch countDownLatch) {this.countDownLatch = countDownLatch;}@Overridepublic void run() {try {countDownLatch.await();out.println("SecondBatchPassenger Executed!");} catch (InterruptedException e) {}}
}
复制代码

输出：

FirstBatchPassenger Executed!
FirstBatchPassenger Executed!
FirstBatchPassenger Executed!
FirstBatchPassenger Executed!
FirstBatchPassenger Executed!
MainThread countDown!
SecondBatchPassenger Executed!
SecondBatchPassenger Executed!
SecondBatchPassenger Executed!
SecondBatchPassenger Executed!
SecondBatchPassenger Executed!
复制代码

进阶三-CyclicBarrier

触发屏障，当await自动达到屏障数量时，触发屏障操作。可重复使用！

public class CyclicBarrierTest {public static void main(String[] args) {CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> out.println("Action GO!"));for (int i = 0; i<6;i++){new CyclicBarrierWorker(cyclicBarrier).start();}}
}class CyclicBarrierWorker extends Thread {private CyclicBarrier cyclicBarrier;public CyclicBarrierWorker(CyclicBarrier cyclicBarrier) {this.cyclicBarrier = cyclicBarrier;}@Overridepublic void run() {out.println("Executed!");try {cyclicBarrier.await();} catch (InterruptedException e) {} catch (BrokenBarrierException e) {}}
}
复制代码

输出：

Executed!
Executed!
Executed!
Action GO!
Executed!
Action GO!
Executed!
Executed!
Action GO!
复制代码