JUC并发包下的工具类

本文主要是介绍JUC并发包下的工具类，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、闭锁CountDownLatch

作用：让当前线程等到一组事件发生后再继续执行

举例：比如，运动员和裁判员，裁判员线程需要等到所有的运动员线程到达之后才可以宣布比赛结束

闭锁中几个重要的方法：

（1）构造方法：public CountDownLatch（int count）：count【需要等待的线程数】

（2）public void countDown（）：线程每调用一次，等待线程的计数器-1（也就是说运动员线程每执行一次，裁判线程计数器-1）

（3）public void await（）throws InterruptedException（）：调用这个方法的线程会阻塞直到计数器减为0

代码如下：


import java.util.concurrent.CountDownLatch;public class TestCountDownLatch {public static void main(String[] args) {CountDownLatch latch=new CountDownLatch(3);Runnable runnable=new Sport(latch);Thread threadA=new Thread(runnable,"运动员A");Thread threadB=new Thread(runnable,"运动员B");Thread threadC=new Thread(runnable,"运动员C");System.out.println("比赛开始");threadA.start();threadB.start();threadC.start();try {latch.await();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("比赛结束");}static class Sport implements Runnable{CountDownLatch latch;public Sport(CountDownLatch latch){this.latch=latch;}@Overridepublic void run() {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"到达");latch.countDown();}}
}

执行结果：

注意：CountDownLatch的对象，当计数器减为0时，不可恢复，也就是不能再用了

二、循环栅栏CyclicBarrier

作用：若干个线程等待所有的线程都到达同一个状态之后，再恢复执行

举例：比如，开会，已知有5个人参加会议，那么到达的每一个人都需要等待5个人全部都到了这一状态才可以开始开会

几个重要的方法：
（1）public CyclicBarrier（int parties）

（2）public CyclicBarrier（int parties，Runnable barrrierAction）

parties:同时等待的线程个数 barrrierAction：恢复执行之前，随机挑选一个线程执行该任务

代码如下：


import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;public class TestCyclicBarrier {public static void main(String[] args) {System.out.println("等待开会");//当所有线程到达barrier状态后，会从所有线程中随机选择一个来执行RunnableCyclicBarrier barrier=new CyclicBarrier(3, new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}});Runnable task=new Participant(barrier);new Thread(task,"员工A").start();new Thread(task,"员工B").start();new Thread(task,"员工C").start();}
}
class Participant implements Runnable{CyclicBarrier barrier;public Participant(CyclicBarrier barrier){this.barrier=barrier;}@Overridepublic void run() {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"到达");try {barrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}System.out.println("开始开会");}
}

运行结果如下：可以看到barrrierAction是在恢复执行之前，随机挑选一个线程执行这个任务

注意：CyclicBarrier的对象的值可以恢复，reset（）方法，可以重复使用

********闭锁和循环栅栏看起来很类似

都是阻塞等待其他线程，但是侧重点不同：

闭锁是只某个线程去等待一组线程结束之后再恢复执行；而循环栅栏是指一组线程都要等到该组线程执行到某个状态之后，再恢复执行

三、Exchanger--线程交换器

作用：两两线程配对后交换数据再同时恢复执行，若线程调用Exchanger.exchange（），缓冲区只有一个线程，

则当前线程阻塞，直到有另一个线程调用Exchanger.exchange（），两线程交换数据

举例：密码的验证，信息的交换，都需要进行数据的交换，就以两个人说话为例

代码如下：

import java.util.concurrent.Exchanger;/*** 用于线程间协作的工具类，它提供一个同步点，在这个同步点，两个线程可以交货彼此的数据* 通过exchange交换数据，如果第一个线程先执行了exchange（）方法，它会已知等待第二个线程也执行exchange（）方法* 当两个线程都到达同步点时，这两个线程就可以交换数据了，将本线程生产出来的数据传递给对方*/
public class TestExchanger {public static void main(String[] args) {Exchanger<String> exchanger=new Exchanger<>();Runnable boy=new boy(exchanger);Runnable girl=new girl(exchanger);new Thread(boy,"Thread-boy").start();new Thread(girl,"Thread-girl").start();}
}
class boy implements Runnable {Exchanger<String> exchanger;public boy(Exchanger exchanger){this.exchanger=exchanger;}@Overridepublic void run() {System.out.println("我是男方");try {String result=exchanger.exchange("男方说的话");System.out.println(Thread.currentThread().getName()+":"+result);} catch (InterruptedException e) {e.printStackTrace();}}
}
class girl implements Runnable{Exchanger<String> exchanger;public girl(Exchanger exchanger){this.exchanger=exchanger;}@Overridepublic void run() {System.out.println("我是女方");try {String result=exchanger.exchange("女方说的话");System.out.println(Thread.currentThread().getName()+":"+result);} catch (InterruptedException e) {e.printStackTrace();}}
}

执行结果如下：可以看到数据进行了交换，双方都接收到了对方的信息数据