这三个类都是基于AQS实现的类，也是面试中常考的类，今天我们来学习一下这三个类的用法。
- CountDownLatch：
Count：数数
Down：向下
Latch：门闩
顾名思义，这个类就是用来“倒计时”的，可以用来让一个线程或多个线程等待多个线程。
下面看例子：
这个例子模拟的是同学下晚自习后，班长关门的事件。正常情况是等所有同学都走完之后，然后班长锁门，离开教室。这里新建五个线程模拟同学，主线程代表班长。
public class Test {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "\t同学离开教室");
},String.valueOf(i)).start();
}
System.out.println(Thread.currentThread().getName() + "班长离开教室，锁门");
}
}
1 同学离开教室
2 同学离开教室
3 同学离开教室
4 同学离开教室
main班长离开教室，锁门
5 同学离开教室
可以看到还剩一位同学没走，班长就把门锁上了，这肯定是不行的，我们来用CountDownLatch来解决这个问题。
import java.util.concurrent.CountDownLatch;
public class Test {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(5);//设置初始门闩值，模拟还有五个同学在教室
for (int i = 1; i <= 5; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "\t同学离开教室");
countDownLatch.countDown();//每有一个同学离开教室，门闩的值就减1
},String.valueOf(i)).start();
}
countDownLatch.await();//门闩的值减到0之前，main线程阻塞
System.out.println(Thread.currentThread().getName() + "班长离开教室，锁门");
}
}
1 同学离开教室
2 同学离开教室
3 同学离开教室
4 同学离开教室
5 同学离开教室
main班长离开教室，锁门
再无论怎么运行，main线程一定会等五个线程都运行之后才会输出。
-
CyclicBarrier
用来控制多个线程互相等待，只有所有线程全部到达后，这些线程才会继续执行。
CyclicBarrier有两个构造方法：public CyclicBarrier(int parties){ }public CyclicBarrier(int parties,Runnable barrierAction){ }当所有的线程都到达时，会触发barrierAction
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Test {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,new Thread(()-> {
System.out.println("召唤神龙");
}));//等待七个线程到位之后，执行"System.out.println("召唤神龙");" 任务。
for (int i = 1; i <= 7; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "颗龙珠已经收集");
try {
cyclicBarrier.await();//设置屏障，等待所有线程到位
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
- semaphore
中文名：信号量，用于控制多个线程对互斥资源的访问控制。
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3); // 模拟总共有三个车位
/*
用六个线程来模拟有六辆车要抢占三个车位
*/
for (int i = 1; i <= 6; i++) {
new Thread(() -> {
try {
semaphore.acquire(); //抢占资源
System.out.println(Thread.currentThread().getName() + "\t抢到车位");
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName() + "\t等待三秒后离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();//释放资源
}
},String.valueOf(i)).start();
}
}
}
1 抢到车位
2 抢到车位
3 抢到车位
2 等待三秒后离开车位
3 等待三秒后离开车位
1 等待三秒后离开车位
4 抢到车位
6 抢到车位
5 抢到车位
4 等待三秒后离开车位
6 等待三秒后离开车位
5 等待三秒后离开车位
