四大并发工具类

java.util.concurrent包下的工具类：
（1） 闭锁 CountDownLatch
主要的构造方法：
public CountDownLatch(int count) : count表示需要等待的线程个数

public void countDown() : 计数器值-1(类似运动员线程[被等待的线程])

public void await() throws InterruptedException : 等待线程调用该方法进入阻塞态，直到计数器减为0.

CountDownLatch对象在计数器值减为0时不可恢复。
只会阻塞调用await方法的线程，不会对子线程造成影响

⽐如有⼀个任务A，它要等待其他4个任务执⾏完毕之后才能执⾏，此时就可以利⽤CountDownLatch来实现这种功能。
例如：运动员和裁判，要等所有的运动员都到达，比赛才结束，裁判才算完成该任务。
程序实现：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

class CDLTask implements Runnable{
private CountDownLatch countDownLatch;
public CDLTask(CountDownLatch countDownLatch){
    this.countDownLatch=countDownLatch;
}
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"已经到达");
        countDownLatch.countDown();
    }
}
public class CountDownLatchTeast {
    public static void main(String[] args) {
        CountDownLatch countDownLatch=new CountDownLatch(3);
        System.out.println("比赛开始");
        try {
        Thread thread1=new Thread(new CDLTask(countDownLatch),"运动员A");
        thread1.start();
        TimeUnit.SECONDS.sleep(2);
        Thread thread2=new Thread(new CDLTask(countDownLatch),"运动员B");
        thread2.start();
        TimeUnit.SECONDS.sleep(2);
        Thread thread3=new Thread(new CDLTask(countDownLatch),"运动员C");
        thread3.start();
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("比赛结束");

    }
}

（2）循环栅栏CyclicBarrier
所有线程必须同时到达 栅栏位置后，才能继续执行
构造方法：
public CyclicBarrier(int parties) : parties表示需要有多少个线程同时暂停以及恢复执行
当调用public int await() : cyclicBarrier 计数器-1，当减为0时，所有阻塞线程同时恢复执行
public CyclicBarrier(int parties, Runnable barrierAction)
多个线程在恢复执行之前，任意挑选一个线程执行barrierAction任务后，再同时恢复执行。
CyclicBarrier计时器值可以恢复，通过调用reset()方法，CyclicBarrier的对象可以重复使用。
程序实现：

class CBTask implements  Runnable {
    private CyclicBarrier cyclicBarrier;

    public CBTask(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在写入数据");
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "写入完成，等待其他线程写入完毕");
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(6, new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程为:"+Thread.currentThread().getName());
            }
        });
        for(int i=0;i<6;i++){
            new Thread(new CBTask(cyclicBarrier)).start();
        }
    }
}

(3)Exchanger交换器
Exchanger用于两个线程交换数据，当缓冲区只有一个线程时，该线程会阻塞直到配对成功再交换数据恢复执行。

代码实例：

public class ExchangerTest {
    public static void main(String[] args) {
        Exchanger<String> exchanger=new Exchanger<>();
        Thread girlThread=new Thread(()->{
            try{
                String girl=exchanger.exchange("hello");
                System.out.println("女生说："+girl);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        });
        girlThread.start();
        Thread boyThread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("她慢慢的走过来");
                try {
                    TimeUnit.MILLISECONDS.sleep(100);
                    String boy=exchanger.exchange("我喜欢你");
                    System.out.println("男生说："+boy);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        boyThread.start();
    }
}

（5）Semaphore信号量
常用的构造方法：
public Semaphore(int permits) : 表示许可的数量
public Semaphore(int permits, boolean fair) : 等待时间最长的线程最先获取到许可
public void acquire() : 申请许可，尝试获取许可
public void release() : 释放许可。在释放许可之前，必须先获得许可。
代码实例：

class SPTask implements Runnable{
    private int number;
 private Semaphore semaphore;
 public SPTask(int number,Semaphore semaphore){
    this.number=number;
     this.semaphore=semaphore;
 }
    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println("工人"+this.number+"占用一台设备在生产");
            TimeUnit.MILLISECONDS.sleep(100);
            System.out.println("工人"+this.number+"释放出本设备");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class SemaphoreTest {
    public static void main(String[] args) {
        int workerNumber=10;
        Semaphore semaphore=new Semaphore(5);
        for(int i=0;i<workerNumber;i++){
            new Thread(new SPTask(i,semaphore)).start();
        }
    }
}

共勉