JUC常用工具类

1.JUC

JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。
分类说明JUC包常用类有哪些

1.1 CountDownLatch

1.1.1 介绍

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。
CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

1.1.2 举例

比如老师检查学生作业，有三个学生，这三个学生需要都做完作业后，老师才一起进行检查。这里，我们把每一个学生对应一个线程，老师对应一个主线程，当主线程要进行检查操作时，必须等待三个线程都处理完了，才开始主线程自己的步骤。

学生类：

/**
 * 学生
 */
public class Student implements Runnable{

    //线程内共享倒计数门阀
    private CountDownLatch downLatch;
    private String name;


    public Student(CountDownLatch downLatch, String name) {
        this.downLatch = downLatch;
        this.name = name;
    }

    public void run() {
        System.out.printf("学生%s 开始做作业！\n",name);
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf("学生%s 作业结束！\n",name);
        //当前线程执行完后，记得调用门阀
        downLatch.countDown();

    }
}

老师类：

/**
 * 老师
 */
public class Teacher {

    public static void main(String[] args) {
        //创建倒计数(CountDown)门闩(Latch)
        CountDownLatch latch = new CountDownLatch(3);
        ExecutorService executor = Executors.newCachedThreadPool();

        executor.execute(new Student(latch,"A"));
        executor.execute(new Student(latch,"B"));
        executor.execute(new Student(latch,"C"));
        //线程池用完了记得关闭，不然资源一直占用，比如main方法会一直在执行
        executor.shutdown();

        System.out.printf("老师%s 等待学生作业！\n",Thread.currentThread().getName());
        try {
            //等待三个线程全部执行完
            latch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf("老师%s 学生作业全部做完，开始检查！\n",Thread.currentThread().getName());

    }

}

打印：

1.1.3 注意

1.各个线程中最好有异常处理，不要让一个线程阻塞了导致请他线程也跟着阻塞

1.2 CyclicBarrier

1.2.1 介绍

CyclicBarrier字面意思是“可重复使用的栅栏”，CyclicBarrier 相比 CountDownLatch 来说，要简单很多，其源码没有什么高深的地方，它是 ReentrantLock 和 Condition 的组合使用。
在CyclicBarrier类的内部有一个计数器，每个线程在到达屏障点的时候都会调用await方法将自己阻塞，此时计数器会减1，当计数器减为0的时候所有因调用await方法而被阻塞的线程将被唤醒。这就是实现一组线程相互等待的原理

1.2.2 举例

例如100米赛跑，有3个运动员参加，教练需要看到3个运动员都准备好了，然后才鸣枪，三个运动员同时起跑。现在三个运动员对应三个线程，当教练(主线程)执行100米比赛时，通过查看cyclicBarrier的计数是否为0，为0则所有线程开始都被唤醒开始同时进行。

远动员：

/**
 * 运动员
 */
public class Player implements Runnable{

    private CyclicBarrier cyclicBarrier;
    private String name;

    public Player(CyclicBarrier cyclicBarrier, String name) {
        this.cyclicBarrier = cyclicBarrier;
        this.name = name;
    }
    public void run() {
        try {
            //睡眠阻塞
            cyclicBarrier.await();
            System.out.printf("运动员%s 开始起跑！时间：%s\n",name,getDateTime());
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf("运动员%s 100米跑道终点！时间：%s\n",name,getDateTime());
    }

    public String getDateTime(){
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(d);
    }
}

教练：

/**
 * 教练
 */
public class Trainer {
    public static void main(String[] args) {
        int threadCount = 3;
        //创建栅栏
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);
        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 1; i <= threadCount; i++) {
            executor.execute(new Player(cyclicBarrier,"A"+i));
            System.out.printf("运动员%s准备就绪，等待其他玩家！\n","A"+i);
        }
        executor.shutdown();
    }
}

打印：

1.2.3 注意

1.CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
2.CountDownLatch 参与的线程的职责是不一样的，有的在倒计时，有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。
3CountDownLatch是线程组之间的等待，即一个(或多个)线程等待N个线程完成某件事情之后再执行；而CyclicBarrier则是线程组内的等待，即每个线程相互等待，即N个线程都被拦截之后，然后依次执行。
4.CountDownLatch是减计数方式，而CyclicBarrier是加计数方式。
5.CountDownLatch计数为0无法重置，而CyclicBarrier计数达到初始值，则可以重置。

1.3 Semaphore

1.3.1 介绍

Semaphore用于限制可以访问某些资源（物理或逻辑的）的线程数目，他维护了一个许可证集合，有多少资源需要限制就维护多少许可证集合，假如这里有N个资源，那就对应于N个许可证，同一时刻也只能有N个线程访问。一个线程获取许可证就调用acquire方法，用完了释放资源就调用release方法。
Semaphore 类是一个计数信号量，必须由获取它的线程释放， 通常用于限制可以访问某些资源（物理或逻辑的）线程数目

1.3.2 举例

比如一个停车场有三个车位，有6辆车进入，那么当停满3辆车后，停车场是不能再进去停车场的，必须其中一个车出来，空出一个车位后，后面的车才能再次进入。车位就相当于Semaphore信号量，车辆可看做一个线程，程序中只允许3个线程进行执行，不管后面线程有多少，当一个线程执行完了，那么后面线程才能有一个开始执行。

车辆类：

public class Car implements Runnable{

    private Semaphore semaphore;
    private String name;

    public Car(Semaphore semaphore, String name) {
        this.semaphore = semaphore;
        this.name = name;
    }

    public void run() {
        try {
            //查看是否还有车位
            semaphore.acquire();
            System.out.printf("车主%s 有车位，开车进入！\n",name);
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
            System.out.printf("车主%s 离开停车场！\n",name);
            //释放占用的车位
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

停车场类：

/**
 * 停车场
 */
public class Park {

    public static void main(String[] args) {
        //信号量，即3个车位
        Semaphore ParkingLot = new Semaphore(3);
        ExecutorService executor = Executors.newCachedThreadPool();
        //6辆车开车进入
        for (int i = 1; i <= 6; i++) {
            executor.execute(new Car(ParkingLot,"A"+i));
        }
        executor.shutdown();
    }

}

打印：

1.3.3 注意

1.4 Exchanger

1.4.1 介绍

Exchanger并发辅助类，允许在并发任务之间交换数据。具体来说Exchanger类在两个线程之间定义同步点。当两个线程到达同步点时，它们交换数据结构。
Exchanger 是 JDK 1.5 开始提供的一个用于两个工作线程之间交换数据的封装工具类，简单说就是一个线程在完成一定的事务后想与另一个线程交换数据，则第一个先拿出数据的线程会一直等待第二个线程，直到第二个线程拿着数据到来时才能彼此交换对应数据。
平时没怎么用到

1.4.2 举例

两个生产者线程，当调用Exchanger时，会互相传递数据

public class ProducerA extends Thread{

    private Exchanger<Integer> exchanger;
    private static int data = 2;

    public ProducerA(Exchanger<Integer> exchanger, String name) {
        super.setName(name);
        this.exchanger = exchanger;
    }

    @Override
    public void run() {

        System.out.println(getName()+" 交换前:" + data);
        try {
            TimeUnit.SECONDS.sleep(2);
            data = exchanger.exchange(data);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName()+" 交换后:" + data);
    }
}

public class ProducerB extends Thread{

    private Exchanger<Integer> exchanger;
    private static int data = 0;

    public ProducerB(Exchanger<Integer> exchanger, String name) {
        this.exchanger = exchanger;
        super.setName(name);
    }

    @Override
    public void run() {
        System.out.println(getName()+" 交换前:" + data);
        try {
            TimeUnit.SECONDS.sleep(1);
            data = exchanger.exchange(data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName()+" 交换后:" + data);
    }
}

public class Test {

    public static void main(String[] args) throws InterruptedException {

        Exchanger<Integer> exchanger = new Exchanger<Integer>();
        new ProducerA(exchanger,"AA").start();
        new ProducerB(exchanger,"BB").start();
        TimeUnit.SECONDS.sleep(5);

    }
}

参考

Java Exchanger 必知必会
Semaphore的工作原理及实例
semaphore/
Semaphore 相关整理
Java并发编程之CyclicBarrier详解
CountDownLatch的理解和使用