Java并发——Java中的并发类工具
在JDK的并发包里面提供了几个非常有用的工具类：CountDwonLatch、CyclicBarrier、Semaphore、Exchanger。
其中CountDwonLatch、CyclicBarrier、Semaphore工具类提供了一种并发流程控制的手段，Exchanger提供了一种在线程间交换数据的手段。
一、四种并发工具类
1、CountDwonLatch（闭锁）
CountDwonLatch用来等待一个或者多个线程完成操作，作用类似于当前线程里调用join（）方法，让当前线程等待join（）进来的线程执行完毕再执行当前线程剩下的逻辑，但是CountDownLatch比join（）的功能更加强大，使用方法如下：
import java.util.concurrent.CountDownLatch;
class test{
static CountDownLatch cdl = new CountDownLatch(2); //①新建一个CountDwonLatch对象并传入计数器的值
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
@Override
public void run() {
try{
System.out.println("thread 1: 1 ");
Thread.sleep(1000);
System.out.println("thread 1 : 2");
cdl.countDown(); //②在被等待的线程或者步骤执行完毕后调用countDwon（）方法让计数器减1
}
catch(InterruptedException e){
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable(){
@Override
public void run(){
try{
System.out.println("thread 2 : 1");
Thread.sleep(1000);
System.out.println("thread 2 : 2");
cdl.countDown();
}
catch(InterruptedException e){
e.printStackTrace();
}
} }).start();
cdl.await(); //③在等待的主线程中调用await（）方法等待其他线程，知道计数器为0 再执行主线程接下来的逻辑
System.out.println("thread : main");
}
}输出结果：
thread 1: 1
thread 2 : 1
thread 1 : 2
thread 2 : 2
thread : mainCountDwonLatch的使用方法：
在CountDwonLatch中，countDwon（）方法和await（）方法搭配使用才能起到类似join（）的作用：
（1）首先创建一个CountDwonLatch对象并传入要等待的线程的数量，这是个计数器；
（2）在被等待的线程或者步骤执行完毕后调用countDwon（）方法让计数器减1，countDwon（）方法是一个等待的计数器，每次调用countDwon（）方法，计数器减1，直到计数器为0，countDwon可以用在任何地方，可以是一个步骤的一个点，也可以是一个线程。
（3）在等待其他线程的主线程中，调用await（）方法来等待其他调用了countDwon（）的线程，直到计数器为0，再执行该线程接下来的逻辑，当然，如果某个线程执行的时间过久，当前线程不可能一直等待，那么可以调用await（long time, TimeUnit unit）方法。
*注意：计数器大于0时才会阻塞当前线程，一旦计数器等于0就不会再阻塞调用await（）的当前线程；
在创建CountDwonLatch时传入计数器的初始值后，计数器就不能重新初始化了；
2、CyclicBarrier（同步屏障）
让一组线程到达一个屏障（或者同步点）时被阻塞，知道所有线程到达同步屏障后，同步屏障开门，所有线程继续执行。
同步屏障的使用：同步屏障有两种使用方式，从CyclicBarrier的构造方式撒谎个可以看出来
//构造器 1
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
//构造器 2
public CyclicBarrier(int parties) {
this(parties, null);
}构造器1：传入要阻塞的线程的数量parties和一个Runnable的对象，这个对象的作用是用于处理以下复杂的业务场景情形：当需要在第一个线程到达屏障前，前处理一个任务，这个任务可以写在barrierAction中。
构造器2：runnable对象为null说明只需要简单的等待其他线程到达同步屏障即可。
接下来举例说明两种同步屏障的使用：
构造器2：
（1）创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量；
（2）在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
import java.util.concurrent.CyclicBarrier;
class test{
static CyclicBarrier cb = new CyclicBarrier(2); //创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量；
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
@Override
public void run() {
try{
cb.await(); //在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
System.out.println(1);
}
catch(Exception e){
System.out.println("thread 1");
}
}
}).start();
try{
cb.await(); //在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
System.out.println(3);
}
catch(Exception e){
System.out.println("main");
}
}
}构造器1：
（1）创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量，和barrierAction对象；
（2）写一个实现Runnable接口的class，用于实现第一个线程到达同步屏障前的业务逻辑；
（3）在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
import java.util.concurrent.CyclicBarrier;
class test{
static CyclicBarrier cb = new CyclicBarrier(2,new DoSomeThing()); //创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量，和barrierAction对象；
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
@Override
public void run() {
try{
cb.await(); // 在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
System.out.println(1);
}
catch(Exception e){
System.out.println("thread 1");
}
}
}).start();
try{
cb.await();
System.out.println(2);
}
catch(Exception e){
System.out.println("main");
}
}
public static class DoSomeThing implements Runnable{ //写一个实现Runnable接口的class，用于实现第一个线程到达同步屏障前的业务逻辑；
@Override
public void run(){
System.out.println("happen-before CyclicBarrier");
}
}
}*注意：
因为cb.await( )方法会抛出InterruptedException和BrokenBarrierException异常，因此在子线程中要使用try-catch方法来捕捉这两种异常；
CyclicBarrier中的线程计数器可以使用reset（）方法重置；
在所有线程到达同步屏障后，并不是所有线程“同时”开始执行，而是使各个线程的启动时间降到最低；
3、Semaphore（信号量）
Semaphore用于流量控制，用于控制访问特定资源的线程数量，通过协调各个线程，以保证合理的使用公共资源。Semaphore就像公路上的交通信号灯或者收费站，用于控制车的流量，如果一条公路只允许10 个车通行，相当于在路口设置一个颁发通行证的收费站，一辆车只有收到了通行证才能进入这条公路，如果通行证颁发完毕了，那么其他的车就先等在收费站外面，如果公路上的车出了这条公路，那么他把通行证还给收费站，收费站又可以继续把通行证颁发给等在收费站外面的车。
Semaphore的使用方法：
（1）创建一个Semaphore对象，并传入一个int类型的参数，初始化通行证数量；
（2）在要占用公共资源的子线程业务逻辑前，调用s.acquire( )方法获得通行证，在实现业务逻辑后，调用release（）方法释放通行证；
import java.util.concurrent.Semaphore;
class test{
static Semaphore s = new Semaphore(5); //创建一个Semaphore对象，并传入一个int类型的参数，初始化通行证数量；
public static void main(String[] args) throws InterruptedException {
for(int i = 0; i<10; i++){
new Thread(new Runnable() {
@Override
public void run() {
try{
s.acquire(); //在要占用公共资源的子线程业务逻辑前，调用s.acquire( )方法获得通行证
System.out.println(Thread.currentThread() + "is saving data " + "availablePermits:" + s.availablePermits() + " getQueueLength:" + s.getQueueLength());
Thread.sleep(1000);
s.release(); //在实现业务逻辑后，调用release（）方法释放通行证；
}
catch(Exception e){
System.out.println("thread 1");
}
}
}).start();
}
}
}输出结果：
Thread[Thread-3,5,main]is saving data availablePermits:4 getQueueLength:0
Thread[Thread-7,5,main]is saving data availablePermits:3 getQueueLength:0
Thread[Thread-0,5,main]is saving data availablePermits:2 getQueueLength:0
Thread[Thread-4,5,main]is saving data availablePermits:1 getQueueLength:0
Thread[Thread-8,5,main]is saving data availablePermits:0 getQueueLength:0
Thread[Thread-2,5,main]is saving data availablePermits:0 getQueueLength:4
Thread[Thread-6,5,main]is saving data availablePermits:0 getQueueLength:3
Thread[Thread-1,5,main]is saving data availablePermits:0 getQueueLength:2
Thread[Thread-5,5,main]is saving data availablePermits:0 getQueueLength:1
Thread[Thread-9,5,main]is saving data availablePermits:0 getQueueLength:0可以发现，我们在代码中，有10个线程在执行，但是只有5个线程并发的执行，剩余的线程都在等待队列中。
Semaphore还有一些其他的方法：
boolean tryAcquire（）尝试获取通行证；
int getQueueLength( )获取等待队列（线程）的长度；
int availablePermits（）获取剩余可用的通行证数量；
boolean QueuedThreads( )是否有线程在等待获取通行证；
void reducePermits(int reduction)减少通行证数量，这是一个protedcted方法；
Cillection getQueuedThreads( )获取等待获取通行证的线程集合，这是个protected方法；
4、Exchanger（交换者）
Exchanger是一个线程间提供数据交换功能的写作工具，他提供了一个同步点，在这个同步点，两个线程可以交换彼此的数据。线程间通过调用excahange（）方法交换数据，如果第一个线程先到达同步点，执行exchange方法，那么他会一直在同步点等待第二个线程到达同步点，第二个线程也执行exchange方法，这时两个线程都到达同步点，可以交换彼此的数据。
使用：
（1）创建一个Exchanger对象；
（2）在要交换（同步）数据的同步点调用excr.exchange( )方法
import java.util.concurrent.Exchanger;
class test{
static Exchanger exc = new Exchanger<>(); //创建一个Exchanger对象；
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
@Override
public void run() {
try{
String A= "银行流水A";
String B = exc.exchange(A); //在要交换（同步）数据的同步点调用excr.exchange( )方法
System.out.println("A的视角： A、B流水是否一致：" + A.equals(B) + " A录入的是：" + A + " B录入的是：" + B);
}
catch(Exception e){
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
try{
String B= "银行流水B";
String A = exc.exchange(B); //在要交换（同步）数据的同步点调用excr.exchange( )方法
System.out.println("B的视角： A、B流水是否一致：" + A.equals(B) + " A录入的是：" + A + " B录入的是：" + B);
}
catch(Exception e){
e.printStackTrace();
}
}
}).start();
}
} 输出：
B的视角： A、B流水是否一致：false A录入的是：银行流水A B录入的是：银行流水B
A的视角： A、B流水是否一致：false A录入的是：银行流水A B录入的是：银行流水B
可以看出，Exchanger的“交换”更偏向于数据的同步与共享，而不是“你的给我，我的给你”这样有来有回的交换，是“你知道一个信息，我知道另一个消息，我们彼此交换了信息，那么我们就都知道了两个消息”。如果不愿意在同步点一直等待另一个线程，那么可以用设置等待时间的exchange方法：excr.exchange(V x, long timeout, timeUnit unit)。
*注意：
Exchanger交换数据是成对的交换；
Exchanger可以看做双向的同步队列，一个线程从个队列头部进行操作，一个从个队列尾部进行操作；
二、并发工具类的使用场景
1、CountDwonLatch：一个线程等到其它几个线程执行完才能执行的场景；
2、CyclicBarrier：需要多线程的计算结果最后对这些结果进行合并的场景；
3、Semaphore：公共资源有限而并发线程较多的场景；
4、Exchanger：需要数据交换共享的场景，例如遗传算法中，需要选择两个人来交配，交换两人的数据并根据交换规则来得到交配结果，再例如用于校对工作，交换两个线程的数据，用于校对两个线程的数据是否相等；
三、并发工具类CountDwonLatch与CyclicBarrier的区别
1、CountDwonLatch阻塞一个线程，CyclicBarrier阻塞多个线程；
2、CountDwonLatch的计数器在构造对象时确定了就不能更改，但是CyclicBarrier可以使用reset（）方法重置计数器；
3、CyclicBarrier的功能更加丰富，比如int getWaitingNumber（）方法返回被阻塞在同步屏障的线程数，boolean isBroken（）方法返回是否有阻塞的线程被中断