本文深入探讨了Java并发编程中CountDownLatch、CyclicBarrier和Semaphore三种工具类的使用场景和区别，详细解释了它们如何帮助控制多线程执行流程，实现线程间的同步与并发限制。
本文整理自Java并发编程
目录
3 CyclicBarrier和CountDownLatch的区别
JDK并发包里提供了几个非常有用的并发工具类。CountDownLatch,CyclicBarrier和Semaphore工具类提供了一种并发流程控制的手段，Exchanger工具类则提供了在线程间交换数据的一种手段。
1 等待多线程完成的CountDownLatch
CountDownLatch允许一个或多个线程等待其他线程完成操作。
使用场景：假如我们需要解析一个Excel里多个sheet数据，此时可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有sheet都解析完成之后，程序需要提示解析完成。在这个需求中，要实现主线程等待所有线程完成操作，可以：
1.1使用join方法：可以让当前执行线程等待join线程执行结束。原理是不停检查join线程是否存活，如果join线程存活则让线程永远等待。知道join线程中止后，线程的this.notifyAll()方法会被调用。
1.2使用JDK1.5之后的CountDownLatch也可以实现join功能：CountDownLatch的构造函数接收一个int型的参数作为计数器，如果想等待N个点完成，就传入N。当调用countDown()方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，知道N变成0.
如果有某个线程处理比较慢，不让主线程一直等待，可以使用await(long time,TimeUnit unit)设置超时时间，等待特定时间后，就会不再阻塞当前线程。
注：计数器必须大于等于0，只是等于0的时候，计数器就是0，调用await方法是不会阻塞当前线程。CountDownLatch不可能重新初始化或者修改CountDownLatch对象的内部计数器的值。一个线程调用countDown方法 happen_before另外一个线程调用await方法。
Demo:
import java.util.concurrent.CountDownLatch;
/**
* 通常用于监听某些初始化操作，等初始化执行完毕之后，通知主线程继续工作
*/
public class UseCountDownLatch {
public static void main(String[] args) {
final CountDownLatch countDown = new CountDownLatch(2);
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("进入线程t1" + "等待其他线程处理完成...");
countDown.await();
System.out.println("t1线程继续执行...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("t2线程进行初始化操作...");
Thread.sleep(3000);
System.out.println("t2线程初始化完毕，通知t1线程继续...");
countDown.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("t3线程进行初始化操作...");
Thread.sleep(4000);
System.out.println("t3线程初始化完毕，通知t1线程继续...");
countDown.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
t2.start();
t3.start();
}
}
执行结果：
进入线程t1等待其他线程处理完成...
t3线程进行初始化操作...
t2线程进行初始化操作...
t2线程初始化完毕，通知t1线程继续...
t3线程初始化完毕，通知t1线程继续...
t1线程继续执行...
2 同步屏障CyclicBarrier
CyclicBarrier可以让一组线程到达一个屏障（也可以叫做同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。
使用场景：可用于多线程计算数据，最后合并计算结果的场景。例如用一个Excel保存用户所有银行流水，每个Sheet保存一个账户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的流水，都执行完成后，得到每个sheet的日均银行流水，最后，再用barrierAction计算出整个Excel的日均银行流水。
CyclicBarrier默认构造方法是CyclicBarrier（int parties）,其参数标识屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
还有一个更高级的构造函数CyclicBarrier（int parties，Runnable barrierAction），用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。
Demo:
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 每个线程代表一个运动员，当所有运动员都准备好之后，才一起出发。只要有一个没有准备好，大家都等待
*/
public class UseCyclicBarrier {
static class Runner implements Runnable {
private CyclicBarrier barrier;
private String name;
public Runner(CyclicBarrier barrier, String name) {
this.barrier = barrier;
this.name = name;
}
@Override
public void run() {
try {
Thread.sleep(1000 * (new Random()).nextInt(5));
System.out.println(name + " 准备OK.");
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(name + " Go!!");
}
}
public static void main(String[] args) throws IOException, InterruptedException {
CyclicBarrier barrier = new CyclicBarrier(3); // 3
ExecutorService executor = Executors.newFixedThreadPool(3);
executor.submit(new Thread(new Runner(barrier, "zhangsan")));
executor.submit(new Thread(new Runner(barrier, "lisi")));
executor.submit(new Thread(new Runner(barrier, "wangwu")));
executor.shutdown();
}
} 执行结果：
wangwu 准备OK.
zhangsan 准备OK.
lisi 准备OK.
lisi Go!!
wangwu Go!!
zhangsan Go!!
3 CyclicBarrier和CountDownLatch的区别
CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景。例如如果发生计算错误，可以重置计数器，并让线程重新执行一次。
CyclicBarrier还提供了其他有用方法，比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。isBroken方法用来了解阻塞的线程是否中断等。
4 控制并发线程数的Semaphore
Semaphore(信号量)是用来控制同时访问特定资源的线程数量，他通过协调各个线程，以保证合理的使用公共资源。
使用场景：Semaphore可以用于做流量控制，特别是公用资源有限的应用场景，比如数据库连接。假如有一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程并发的读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接只有10个，这时我们必须控制只有10个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。这个时候，就可以使用Semaphore来做流量控制。
Semaphore的构造方法Semaphore（int permits）接受一个整型的数字，标识可用的许可证数量。Semaphore(10)表示允许10个线程获取许可证，也就是最大并发数是10.Semaphore的acquire()方法获取一个许可证，使用完之后调用release()方法归还许可证。还可以用tryAcquire()方法尝试获取许可证。
其他方法：int availablePermits():返回此信号量中当前可用的许可证数
int getQueueLength():返回正在等待获取许可证的线程数
boolean hasQueuedThreads():是否有线程正在等待获取许可证
void reducePermits(int reduction):减少reduction个许可证，是个protected方法
Collection getQueuedThreads():返回所有等待获取许可证的线程集合，protected方法。
Demo：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* Semaphore可以控制系统流量，拿到信号量的线程可以进入，否则就等待，通过acquire()和release()获取和释放访问许可
*/
public class UseSemaphore {
public static void main(String[] args) {
// 线程池
ExecutorService exec = Executors.newCachedThreadPool();
// 只能5个线程同时访问
final Semaphore semp = new Semaphore(5);
// 模拟20个客户端访问
for (int index = 0; index < 20; index++) {
final int NO = index;
Runnable run = new Runnable() {
public void run() {
try {
// 获取许可
semp.acquire();
System.out.println("Accessing: " + NO);
//模拟实际业务逻辑
Thread.sleep((long) (Math.random() * 10000));
// 访问完后，释放
semp.release();
} catch (InterruptedException e) {
}
}
};
exec.execute(run);
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("正在等待获取许可证的线程数:" + semp.getQueueLength());
// 退出线程池
exec.shutdown();
}
} 执行结果：开始会有5个线程执行，之后每退出一个，就会进入一个。
Accessing: 1
Accessing: 4
Accessing: 3
Accessing: 2
Accessing: 0
正在等待获取许可证的线程数:15
Accessing: 5
Accessing: 6
Accessing: 7
Accessing: 8
Accessing: 11
Accessing: 12
Accessing: 15
Accessing: 16
Accessing: 9
Accessing: 10
Accessing: 13
Accessing: 19
Accessing: 14
Accessing: 17
Accessing: 18
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
