java.util.concurrent包下的工具类:
(1) 闭锁 CountDownLatch
主要的构造方法:
public CountDownLatch(int count) : count表示需要等待的线程个数
public void countDown() : 计数器值-1(类似运动员线程[被等待的线程])
public void await() throws InterruptedException : 等待线程调用该方法进入阻塞态,直到计数器减为0.
CountDownLatch对象在计数器值减为0时不可恢复。
只会阻塞调用await方法的线程,不会对子线程造成影响
⽐如有⼀个任务A,它要等待其他4个任务执⾏完毕之后才能执⾏,此时就可以利⽤CountDownLatch来实现这种功能。
例如:运动员和裁判,要等所有的运动员都到达,比赛才结束,裁判才算完成该任务。
程序实现:
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
class CDLTask implements Runnable{
private CountDownLatch countDownLatch;
public CDLTask(CountDownLatch countDownLatch){
this.countDownLatch=countDownLatch;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"已经到达");
countDownLatch.countDown();
}
}
public class CountDownLatchTeast {
public static void main(String[] args) {
CountDownLatch countDownLatch=new CountDownLatch(3);
System.out.println("比赛开始");
try {
Thread thread1=new Thread(new CDLTask(countDownLatch),"运动员A");
thread1.start();
TimeUnit.SECONDS.sleep(2);
Thread thread2=new Thread(new CDLTask(countDownLatch),"运动员B");
thread2.start();
TimeUnit.SECONDS.sleep(2);
Thread thread3=new Thread(new CDLTask(countDownLatch),"运动员C");
thread3.start();
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("比赛结束");
}
}
(2)循环栅栏CyclicBarrier
所有线程必须同时到达 栅栏位置后,才能继续执行
构造方法:
public CyclicBarrier(int parties) : parties表示需要有多少个线程同时暂停以及恢复执行
当调用public int await() : cyclicBarrier 计数器-1,当减为0时,所有阻塞线程同时恢复执行
public CyclicBarrier(int parties, Runnable barrierAction)
多个线程在恢复执行之前,任意挑选一个线程执行barrierAction任务后,再同时恢复执行。
CyclicBarrier计时器值可以恢复,通过调用reset()方法,CyclicBarrier的对象可以重复使用。
程序实现:
class CBTask implements Runnable {
private CyclicBarrier cyclicBarrier;
public CBTask(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "正在写入数据");
try {
TimeUnit.MILLISECONDS.sleep(1000);
System.out.println(Thread.currentThread().getName() + "写入完成,等待其他线程写入完毕");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
public class CyclicBarrierTest {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier=new CyclicBarrier(6, new Runnable() {
@Override
public void run() {
System.out.println("当前线程为:"+Thread.currentThread().getName());
}
});
for(int i=0;i<6;i++){
new Thread(new CBTask(cyclicBarrier)).start();
}
}
}
(3)Exchanger交换器
Exchanger用于两个线程交换数据,当缓冲区只有一个线程时,该线程会阻塞直到配对成功再交换数据恢复执行。
代码实例:
public class ExchangerTest {
public static void main(String[] args) {
Exchanger<String> exchanger=new Exchanger<>();
Thread girlThread=new Thread(()->{
try{
String girl=exchanger.exchange("hello");
System.out.println("女生说:"+girl);
}catch(InterruptedException e){
e.printStackTrace();
}
});
girlThread.start();
Thread boyThread=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("她慢慢的走过来");
try {
TimeUnit.MILLISECONDS.sleep(100);
String boy=exchanger.exchange("我喜欢你");
System.out.println("男生说:"+boy);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
boyThread.start();
}
}
(5)Semaphore信号量
常用的构造方法:
public Semaphore(int permits) : 表示许可的数量
public Semaphore(int permits, boolean fair) : 等待时间最长的线程最先获取到许可
public void acquire() : 申请许可,尝试获取许可
public void release() : 释放许可。在释放许可之前,必须先获得许可。
代码实例:
class SPTask implements Runnable{
private int number;
private Semaphore semaphore;
public SPTask(int number,Semaphore semaphore){
this.number=number;
this.semaphore=semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("工人"+this.number+"占用一台设备在生产");
TimeUnit.MILLISECONDS.sleep(100);
System.out.println("工人"+this.number+"释放出本设备");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class SemaphoreTest {
public static void main(String[] args) {
int workerNumber=10;
Semaphore semaphore=new Semaphore(5);
for(int i=0;i<workerNumber;i++){
new Thread(new SPTask(i,semaphore)).start();
}
}
}
共勉