四大并发工具类

四⼤并发⼯具类的使⽤

1 CountDownLatch-闭锁

CountDownLatch类位于java.util.concurrent包下，利⽤它可以实现类似计数器的功能。⽐如有⼀个任
务A，它要等待其他4个任务执⾏完毕之后才能执⾏，此时就可以利⽤CountDownLatch来实现这种功能
了。
CountDownLatch类只提供了⼀个构造器：
下⾯这3个⽅法是CountDownLatch类中最重要的⽅法：
图示:
代码实例:

public CountDownLatch(int count) { }; //参数count为计数值
//调⽤await()⽅法的线程会被挂起，它会等待直到count值为0才继续执⾏
public void await() throws InterruptedException { };
//和await()类似，只不过等待⼀定的时间后count值还没变为0的话就会继续执⾏
public boolean await(long timeout, TimeUnit unit) throws InterruptedException
{ };
//将count值减1
public void countDown() { };
package bittech.concurrent_utils;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

2.2 CyclicBarrier-循环栅栏
通过它可以实现让⼀组线程等待⾄某个状态之后再全部同时执⾏。叫做回环是因为当所有等待线程都被
释放以后，CyclicBarrier可以被重⽤。我们暂且把这个状态就叫做barrier，当调⽤await()⽅法之后，线
程就处于barrier了。
CyclicBarrier提供2个构造器：

class Task implements Runnable {
 private CountDownLatch countDownLatch;
 public Task(CountDownLatch countDownLatch) {
 this.countDownLatch = countDownLatch;
 }
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName()+"已经到达");
 countDownLatch.countDown();
 }
}
public class CountDownLatchDemo {
 public static void main(String[] args) {
 try {
 new CountDownLatchDemo().test();
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 private void test() throws Exception{
 CountDownLatch countDownLatch = new CountDownLatch(3);
 System.out.println("⽐赛开始!");
 new Thread(new Task(countDownLatch),"运动员A").start();
 TimeUnit.SECONDS.sleep(1);
 new Thread(new Task(countDownLatch),"运动员B").start();
 TimeUnit.SECONDS.sleep(1);
 new Thread(new Task(countDownLatch),"运动员C").start();
 countDownLatch.await();
 System.out.println("⽐赛结束!");
 }
}

参数parties指让多少个线程或者任务等待⾄barrier状态；参数barrierAction为当这些线程都达到
barrier状态时会执⾏的内容。
CyclicBarrier中最重要的⽅法就是await⽅法，它有2个重载版本：
第⼀个版本⽐较常⽤，⽤来挂起当前线程，直⾄所有线程都到达barrier状态再同时执⾏后续任务；
第⼆个版本是让这些线程等待⾄⼀定的时间，如果还有线程没有到达barrier状态就直接让到达barrier
的线程执⾏后续任务。
图示:
代码实例:

public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit) throws
InterruptedException,BrokenBarrierException,TimeoutException { };
package bittech.concurrent_utils;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

class CyclicBarrierTask implements Runnable {
 private CyclicBarrier cyclicBarrier;
 public CyclicBarrierTask(CyclicBarrier cyclicBarrier) {
 this.cyclicBarrier = cyclicBarrier;
 }
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName()+"正在写⼊数据...");
 try {
 TimeUnit.SECONDS.sleep(2);
 System.out.println(Thread.currentThread().getName()+"写⼊数据完毕，等
待其他线程写⼊完毕...");
 cyclicBarrier.await();
 } catch (InterruptedException e) {
 e.printStackTrace();
 } catch (BrokenBarrierException e) {
 e.printStackTrace();
 }
 System.out.println("所有线程写⼊完毕，继续执⾏其他任务...");
 }
}
public class CyclicBarrierDemo {
 public static void main(String[] args) {
 CyclicBarrier cyclicBarrier = new CyclicBarrier(4, new Runnable() {
 @Override
 public void run() {
 System.out.println("当前线程
为"+Thread.currentThread().getName());
 }
 });
 for (int i = 0;i < 4;i++) {
 new Thread(new CyclicBarrierTask(cyclicBarrier)).start();
 }
 }
}

Semaphore类中⽐较重要的⼏个⽅法，⾸先是acquire()、release()⽅法：
acquire()⽤来获取⼀个许可，若⽆许可能够获得，则会⼀直等待，直到获得许可。
release()⽤来释放许可。注意，在释放许可之前，必须先获获得许可。
图示:
代码实例:

//参数permits表示许可数⽬，即同时可以允许多少线程进⾏访问
public Semaphore(int permits) {
 sync = new NonfairSync(permits);
}
//这个多了⼀个参数fair表示是否是公平的，即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair) {
 sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
//获取⼀个许可
public void acquire() throws InterruptedException { }
//获取permits个许可
public void acquire(int permits) throws InterruptedException { }
//释放⼀个许可
public void release() { }
//释放permits个许可
public void release(int permits) { }

2.4 Exchanger-交换器
Exchanger⼀般⽤于两个⼯作线程之间交换数据。

class SemaphoreTask implements Runnable{
 private int num;
 private Semaphore semaphore;
 public SemaphoreTask(int num, Semaphore semaphore) {
 this.num = num;
 this.semaphore = semaphore;
 }
 @Override
 public void run() {
 try {
 semaphore.acquire();
 System.out.println("⼯⼈"+this.num+"占⽤⼀台设备在⽣产");
 TimeUnit.SECONDS.sleep(2);
 System.out.println("⼯⼈"+this.num+"释放出本设备");
 semaphore.release();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
}
public class SemaphoreDemo {
 public static void main(String[] args) {
 int worker = 8;
 Semaphore semaphore = new Semaphore(5);
 for (int i = 0;i < worker;i++) {
 new Thread(new SemaphoreTask(i,semaphore)).start();
 }
 }
}

代码实例:

package bittech.concurrent_utils;
import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeUnit;
/**
* @Author: yuisama
* @Date: 2019-02-17 23:47
* @Description:
*/
public class ExchangerDemo {
 public static void main(String[] args) {
 Exchanger exchanger = new Exchanger<>();
 Thread grilThread = new Thread(new Runnable() {
 @Override
 public void run() {
 try {
 String gril = exchanger.exchange("我暗恋你很久了...");
 System.out.println("⼥⽣说:"+gril);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 });
 grilThread.start();
 Thread boyThread = new Thread(new Runnable() {
 @Override
 public void run() {
 try {
 System.out.println("⼥神慢慢地从教室⾥⾛出来...");
 TimeUnit.SECONDS.sleep(2);
 String boy = exchanger.exchange("我喜欢你!");
 System.out.println("男⽣说:"+boy);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 });
 boyThread.start();
 }
}