概述
在JDK的并发包(java.util.concurrent)中,为我们提供了几个非常重要的并发工具类,分别为CountDownLatch、CyclicBarrier、Semaphore和Exchanger,下面将一一对这几个类的功能及基本用法做详细讲解。
1)CountDownLatch
CountDownLatch,类似于计数器的方式,用于等待一个或多个线程执行完操作开始自身代码的执行。
其构造函数接收一个int类型的整数作为计数器而使用,例如如果想等待N个线程执行完毕就传入N,当每调用一次countDown函数,表示某一个线程执行完毕。实际上,这个N并不是与线程绑定,也就是说并不是一定和线程的数量一致,只需要countDown函数执行N次,当前等待的线程就会开始执行。下面列出具体代码:
public class CountDownLatchTest {
static CountDownLatch countDownLatch = new CountDownLatch(2);
public static void main(String []args) {
new Thread(new Runnable() {
@Override
public void run() {
SleepUtils.second(2);
System.out.println("1");
countDownLatch.countDown();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SleepUtils.second(4);
System.out.println("2");
countDownLatch.countDown();
}
}).start();
try {
// 主线程开始等待
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3");
}
}
输出如下:
1
2
3
Process finished with exit code 0
注意点
1、如果传入的参数大于2,那么主线程将会一直等待。
2、计数器必须大于0,如果为0,调用await方法不会阻塞当前线程。
应用场景
当遇到一个比较耗时的计算量较大的任务时,我们则可以考虑使用多线程来操作,将一个大任务拆分成多个小任务(一个任务相当于一个线程),当每个小任务执行完毕返回结果后,再由某一主线程对结果进行统计。
2)CyclicBarrier
CyclicBarrier即同步屏障,它主要功能是让一组线程达到一个屏障(也可以称为同步点)是被阻塞,直到最后一个线程达到屏障是,屏障才被打开,所有被拦截的线程才会继续执行。
其构造函数默认也是接收一个int类型的参数N作为屏障拦截的线程数量,每个线程调用await方法表示到达了屏障点,然后被阻塞。具体示例如下:
public class CyclicBarrierTest {
// 参数表示屏障拦截的线程数量, 每个线程调用 await方法,告诉CyclicBarrier我已经到达了屏障,然后当前线程被阻塞
// 屏障拦截的线程数量必须和当前的线程数一致,并且都调用await方法,否则当前所有的线程都处于等待状态
static CyclicBarrier c = new CyclicBarrier(3);
public static void main(String []args){
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("1---1 "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
c.await();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1---2 "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("2---1 "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
c.await();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("2---2 "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}).start();
SleepUtils.second(2);
System.out.println("3---1 "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
c.await();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3---2 "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
输出如下:
1---1 17:05:01
2---1 17:05:01
3---1 17:05:03
3---2 17:05:03
1---2 17:05:03
2---2 17:05:03
Process finished with exit code 0
注意点
1、构造函数中的N必须为线程的总数,当最后一个线程调用await方法(到达屏障)时,屏障才会打开,被阻塞的线程才会执行,这里的N表示的含义和CountDownLatch传入的N是不一样的。
2、我们发现,当所有线程都到达屏障时,当屏障打开,接下来会优先执行哪个线程呢?如上代码答案是不确定的。但是CyclicBarrier为我们提供了一个更高级的用法,即构造函数还支持传递一个Runnable对象,当屏障打开时,优先执行Runnable中的run方法。(这一功能十分强大,完全可以替代CountDownLatch了)
应用场景
同CountDownLatch
与CountDownLatch区别:
CountDownLatch计数器只能使用一次,而CyclicBarrier的计数器可以使用 reset方法重置,所以适合更复杂的业务场景。
3)Semaphore
Semaphore即信号量,主要用来控制并发访问特定资源的线程数量,协调各个线程合理使用公共资源。
构造函数同样也是接收一个int类型的参数N作为入参,用来限制访问某一公共资源最大的线程并发数,通过acquire来获取许可证,release释放许可证。
具体示例如下:
public class SemaphoreTest {
private static final int THREAD_COUNT = 6;
private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
private static Semaphore semaphore = new Semaphore(2);
public static void main(String []args){
for(int i=0; i<THREAD_COUNT; i++){
threadPool.execute(new MyRunnable(i+1));
}
threadPool.shutdown();
}
static class MyRunnable implements Runnable{
private int sleep;
public MyRunnable(int sleep) {
this.sleep = sleep;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("save data "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
SleepUtils.second(sleep);
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出如下:
save data 19:44:37
save data 19:44:37
save data 19:44:38
save data 19:44:39
save data 19:44:41
save data 19:44:43
Process finished with exit code 0
注意点
1、通过输出可以发现,线程的并发数量为2,当有一个线程执行完后则下一个线程才获取到资源。
应用场景
我们有大量的线程在完成一个巨量任务的时候,但是某一公共资源却有限定了线程的链接树,这时候就需要对这些大量线程访问这一公共资源做控制。例如当我们有上百个线程需要处理本地上G的数据文件,每个线程处理完成之后需要把结果写到数据库,而数据库只支持十个线程的并发链接,此时,对数据库的链接我们就可以通过Semaphore来控制最大连接数。
4)Exchanger
Exchanger(交换者),它是用于线程间的协作工具类,主要用于线程间数据的交换。它提供了一个同步点,在这个同步点,两个线程可以交换彼此的数据。下面看具体demo:
public class ExchangerTest {
private static final Exchanger<String> exchanger = new Exchanger<>();
private static ExecutorService threadPool = Executors.newFixedThreadPool(2);
public static void main(String[] args){
threadPool.execute(new Runnable() {
@Override
public void run() {
String a = "aaaaaaaaaa";
try {
String b = exchanger.exchange(a);
System.out.println("---"+b);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
String b = "bbbbbbbb";
String a = exchanger.exchange("bababa");
System.out.println("a is "+a+" , b is "+b);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
threadPool.shutdown();
}
}
输出如下:
---bababa
a is aaaaaaaaaa , b is bbbbbbbb
Process finished with exit code 0
注意点
1、Exchanger只能作用于两个线程之间,如果作用于第三个线程,则第三个线程一直处于等待中;
2、exchange中还有一个重载函数,接收一个等待时长,用于避免一直等待。
总结
1、CountDownLatch,它是一种计数器的方式保证线程同步;它不去控制多个子线程之间的前后关系,只保证某一线程能够在这些子线程执行完成后再执行。
2、CyclicBarrier,通过设置屏障的方式使得多线程同步,能够控制多个线程在屏障处等等其他线程也执行到屏障点,可以实现CountDownLatch具有的功能,但是比CountDownLatch功能强大;
3、Semaphore,信号量,用于控制访问某一公共资源的并发线程数;
4、Exchanger,用于两个线程之间的数据交换。