juc包下的关于并发四大工具类

juc包下关于并发的四大工具类

##CountDownLatch—闭锁

使用CountDownLatch可以实现类似多线程下计数器的功能。

构造器：

1.参数count为计数器

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

​ 重载：public boolean await(long await ,TimeUnit unit)throw InterruptedException{}//等到一定时间count还没有减到0，继续执行。

3.public void countDown（）{}

CountDownLatch在计数器值减为0之后无法还原——这就是他为什么值会减为0.

class Sync implements Runnable{
    private CountDownLatch latch;

    public Sync(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+"到达终点");
            latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch=new CountDownLatch(5);
        System.out.println("比赛开始");
        for (int i=0;i<5;i++){
            new Thread(new Sync(latch),"运动员"+(i+1)).start();
        }
        //调用await()方法阻塞当前线程，当所有子线程执行完毕，主线程恢复执行
        latch.await();
        System.out.println("比赛结束");
    }
}

##CyclicBarrier—循环栅栏

通过它，可以让一组线程等待至某个状态之后再全部执行。叫做回环是因为当所有线程都被释放后，CycliBarrier提供两个构造器：

public CyclicBarrier(int parties, Runnable barrierAction)//多的参数是随机挑选一个线程恢复执行后所有线程恢复执行
public CyclicBarrier(int parties)//所有线程到达终点的个数

应用场景：子线程在望主内存写数据

参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会恢复执行，恢复执行之前随机挑选一个执行任务。

//子线程调用await方法后将计数器值-1，并进入阻塞状态；直到计数器值减为0时，所有调用await()方法在同时恢复执行，
public int await() throws InterruptedException, BrokenBarrierException

public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException

第一个版本比较常用：直至所有线程到达barrier状态再同时执行后续任务；

第二个版本是让这些线程等待至一定时间，如果还有线程没有达到barrier状态就直接让达到barrier的线程执行后续任务。

每个CyclicBarrier的计数器可以重复使用

class Sycn implements Runnable{
    private CyclicBarrier cyclicBarrier;

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

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName()+"正在写作");
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+"写完");
            //相当于一面墙,每调用一次await()方法计数器-1，当为0时所有线程恢复执行
            cyclicBarrier.await();
            System.out.println("出版");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

    }
}
//循环栅栏
public class Test{
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(5);
        for (int i=0;i<5;i++){
            new Thread(new Sycn(cyclicBarrier),"作家"+(i+1)).start();
        }
    }
}

Semaphore——信号量：控制某个资源可同时访问的线程个数

应用场景：五个设备，8台生产个工人，工人轮流使用设备。

class Factory implements Runnable{
    private Semaphore s;

    public Factory(Semaphore s) {
        this.s = s;
    }

    @Override
    public void run() {

        try {
            s.acquire();
            System.out.println(Thread.currentThread().getName()+"使用设备");
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName()+"结束");
            s.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
public class Main{
    public static void main(String[] args) {
        Semaphore s=new Semaphore(5);
        Factory factory=new Factory(s);
        for(int i=0;i<8;i++){
            new Thread(factory).start();
        }

    }


}

Exchanger—交换器 两个线程到达同步点后交换数据

线程数据交换器——

1.构造方法

2.exchanger(),

应用场景：一般用于两个线程交换数据；

首先调用exchanger方法的线程会阻塞直到有新的线程进入缓冲区，

交换彼此线程数据再同时恢复执行，

public class Test{
    public static void main(String[] args) {
        Exchanger exchanger=new Exchanger();
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("等待交换数据....");
                try {
                    String str= (String) exchanger.exchange("给你一朵小花花");
                    System.out.println(Thread.currentThread().getName()+" :"+str);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"大猪猪");
        thread1.start();
        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String string= (String) exchanger.exchange("给你你个大牛牛");
                    System.out.println(Thread.currentThread().getName()+" :"+string);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"大实时");
        thread2.start();
    }
}