在 JDK1.5 后,推出了几个并发的工具类,位于 JUC(java.util.concurrent)包下。
CountDownLatch
CountDownLatch 类是使一个线程等待其他线程各自执行完毕后再执行。
类似于现实中某个活动需要等到全部人齐了才可以开始。
实现原理:
- 基于 AQS 的共享模式。
- 这个类是一个同步计数器,主要用于线程间的控制。
- 当 CountDownLatch 的 count 计数 > 0 时,本线程的 await() 会造成阻塞,知道 count 变为 0,开始执行本线程。
package test;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test1 {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2); // 计数器初始化为 2,要等两个线程执行完毕
System.out.println("主线程开始执行");
ExecutorService es1 = Executors.newSingleThreadExecutor();
es1.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println("子线程:" + Thread.currentThread().getName() + "执行");
}catch (InterruptedException e){
e.printStackTrace();
}
latch.countDown(); // 使计数器减一
}
});
ExecutorService es2 = Executors.newSingleThreadExecutor();
es2.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("子线程:" + Thread.currentThread().getName() + "执行");
latch.countDown();
}
});
System.out.println("等待两个线程执行完毕");
try {
latch.await(); // 主线程挂起,等待两个线程执行完
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("两个子线程都执行完毕,继续执行主线程");
}
}
主线程开始执行
等待两个线程执行完毕
子线程:pool-2-thread-1执行
子线程:pool-1-thread-1执行
两个子线程都执行完毕,继续执行主线程
CyclicBarrier
与 CountDownLatch 功能一样,不过它可以重复循环,而 CountDownLatch 只能执行一次。
实现原理:
- 基于 ReentrantLock 和 Condition
//同步操作锁
private final ReentrantLock lock = new ReentrantLock();
//线程拦截器
private final Condition trip = lock.newCondition();
//每次拦截的线程数
private final int parties;
//换代前执行的任务
private final Runnable barrierCommand;
//表示栅栏的当前代
private Generation generation = new Generation();
//计数器
private int count;
//静态内部类Generation
private static class Generation {
boolean broken = false;
- 上面贴出了 CyclicBarrier 所有的成员变量,可以看到 CyclicBarrier 内部使通过条件 trip 来对线程进行阻塞。
- 并且其内部维护了两个 int 型变量 parites 和 count,parties 表示每次拦截的线程数,该值在构造时进行赋值。count 是内部计数器,他的初始值和 parties 相同,以后随着每次 await 方法的调用而减一,直到减为零将唤醒主线程。
- CyclicBarrier 有一个静态内部类 Generation,该类的对象代表栅栏的当前代,就想玩游戏时代表的本局游戏,利用它可以实现循环等待。
- barrierCommand 表示换代前执行的任务,当 count 减为零时表示本局游戏结束,需要转到下一局。在转到下一局游戏之前,利用它可以实现循环等待。
package test;
import java.util.concurrent.CyclicBarrier;
public class Test2 {
static class TaskThread extends Thread{
CyclicBarrier barrier;
public TaskThread(CyclicBarrier barrier){
this.barrier = barrier;
}
@Override
public void run(){
try{
Thread.sleep(100);
System.out.println(getName() + "到达栅栏 A");
barrier.await(); // 等待所有线程都执行到这,才执行主线程
System.out.println(getName() + "冲破栅栏 A"); // 主线程完成后继续执行
Thread.sleep(2000);
System.out.println(getName() + "到达栅栏 B");
barrier.await();
System.out.println(getName() + "冲破栅栏 B");
}catch (Exception e){
e.printStackTrace();
}
}
}
public static void main(String[] args) {
int threadNum = 5;
CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "完成任务");
}
});
for (int i = 0; i < threadNum; i++) {
new TaskThread(barrier).start();
}
}
}
Semaphore
该类用于控制信号量的个数,可以控制同时访问资源的线程个数,并提供了同步机制。例如,实现一个文件允许的并发访问数。
Semaphore 的主要方法:
- acquire():从此信号量中获取一个许可,若已超过许可量,则阻塞此请求线程。
- release():释放一个许可,将其返回给信号量。
- availablePermits():返回此信号量中当前可用的许可数。
- hasQueuedThreads():查询是否有线程正在等待获取。
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class Test {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final Semaphore sp = new Semaphore(3); // 创建 Semaphore 信号量,初始化许可大小为3
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
sp.acquire(); // 请求获取许可,如果有可获取许可,则继续往下指向,许可数减一。
} catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() +
"进入,当前已有" + (3 - sp.availablePermits()) + "个并发") ;
try{
Thread.sleep((long)(Math.random() * 10000));
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() + "即将离开");
sp.release(); // 释放许可证,许可数+1
}
};
service.execute(runnable);
}
}
}
Exchanger
这个类用于交换数据,只能用于两个线程。当一个线程运行到 exchange() 方法时会阻塞,另一个线程运行到 exchange() 时,两者交换数据,然后执行后面的程序。
package test;
import java.util.concurrent.Exchanger;
public class Test3 {
static class Producer extends Thread{ // 生产者线程
private Exchanger<Integer> exchanger; // 交换标志
private static int data = 0;
Producer(String name, Exchanger<Integer> exchanger){
super("Producer-" + name);
this.exchanger = exchanger;
}
@Override
public void run(){
for (int i = 1; i < 5; i++) {
try {
Thread.sleep(1000);
data = i;
System.out.println(getName() + "交换前:" + data);
data = exchanger.exchange(data); // 将此 data 与 消费者的 data 进行交换
System.out.println(getName() + "交换后:" + data);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
static class Consumer extends Thread{ // 消费者线程
private Exchanger<Integer> exchanger; // 交换标志
private static int data = 0;
Consumer(String name, Exchanger<Integer> exchanger){
super("Consumer-" + name);
this.exchanger = exchanger;
}
@Override
public void run(){
while(true){
data = 0;
System.out.println(getName() + "交换前:" + data);
try{
data = exchanger.exchange(data); // 将此 data 与生产者的 data 进行交换,因为先执行到这,会阻塞知道生产者执行到交换
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(getName() + "交换后:" + data);
}
}
}
public static void main(String[] args) throws InterruptedException {
Exchanger<Integer> exchanger = new Exchanger<>();
new Producer("", exchanger).start();
new Consumer("", exchanger).start();
Thread.sleep(7000);
}
}