一:CountDownLatch
import java.util.concurrent.CountDownLatch;
class CountDownLatchDemo {
/**
* CountDownLatch:闭锁
* 在完成一组正在其他线程中执行的操作之前,它约束一个或多个线程一直等待。
* 可用于:子任务执行完成后再进行另一个操作。
*/
static void test(int threadTaskNum) {
final CountDownLatch answers = new CountDownLatch(threadTaskNum);//同步计数器
for (int i = 0; i < threadTaskNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 开始处理任务 ...");
Thread.sleep((long) (Math.random() * 5000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕,汇报结果!");
answers.countDown();
} catch (Exception e) {}
}
}).start();
}
try {
answers.await();// 在所有子线程结束前保持阻塞
} catch (InterruptedException e) {}
System.out.println("线程" + Thread.currentThread().getName() + "已收到所有汇报结果");
}
}
public class Test {
public static void main(String[] args) {
CountDownLatchDemo.test(3);
}
}
输出结果:
线程Thread-0 开始处理任务 ...
线程Thread-1 开始处理任务 ...
线程Thread-2 开始处理任务 ...
线程Thread-0 处理完毕,汇报结果!
线程Thread-1 处理完毕,汇报结果!
线程Thread-2 处理完毕,汇报结果!
线程main已收到所有汇报结果
当所有子线程执行完毕以后,主线程再进行下一步。 (理解为“减法”)
二:CyclicBarrier
import java.util.concurrent.CyclicBarrier;
class CyclicBarrierDemo {
/**
* CyclicBarrier:关卡
* 它约束多线程必需同时达到某时刻,同时向下执行,在没有达到之前保持等待
* 比如:周末约定去爬山,在公司门口集合,必须要等所有人都到后大家在一起出发。
*/
static void test(int threadNum) {
// CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
// 构造方法可支持一个Runnable,用于在所有线程都达到后首先执行。
final CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("都准备好了!");
}
});
for (int i = 0; i < threadNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 已经准备好.");
cyclicBarrier.await();
Thread.sleep((long) (Math.random() * 2000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕,汇报结果!");
} catch (Exception e) {}
}
}).start();
}
}
}
public class Test {
public static void main(String[] args) {
CyclicBarrierDemo.test(3);
}
}
输出结果:
线程Thread-0 已经准备好.
线程Thread-1 已经准备好.
线程Thread-2 已经准备好.
都准备好了!
线程Thread-1 处理完毕,汇报结果!
线程Thread-0 处理完毕,汇报结果!
线程Thread-2 处理完毕,汇报结果!
三个线程相互等待直到都准备好了以后同时开始向下执行。 (理解为“加法”)
三:Semaphore
import java.util.concurrent.Semaphore;
class SemaphoreDemo {
/**
* Semaphore:信号量
* 当前在多线程环境下被扩放使用,操作系统的信号量是个很重要的概念,在进程控制方面都有应用。
* Java 并发库 的Semaphore 可以很轻松完成信号量控制,
* Semaphore可以控制某个资源可被同时访问的个数,
* 通过 acquire() 获取一个许可,如果没有就等待,
* 通过 release() 释放一个许可。
* 比如在Windows下可以设置共享文件的最大客户端访问个数。
*/
static void test(int threadNum) {
// Semaphore semaphore = new Semaphore(threadNum, true);// 是否公平
final Semaphore semaphore = new Semaphore(3);//最多同时允许 3 个线程并发访问
for (int i = 0; i < threadNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 想要处理,剩余凭证:" + semaphore.availablePermits());
semaphore.acquire();
Thread.sleep((long) (Math.random() * 2000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕,归还凭证!");
// 如果注释下面这行,表示不释放凭证,那么后续线程将永远阻塞在semaphore.acquire();上
semaphore.release();// 用完后要释放,以给其它线程使用
} catch (Exception e) {}
}
}).start();
}
}
}
public class Test {
public static void main(String[] args) {
SemaphoreDemo.test(5);
}
}
输出结果:
线程Thread-0 想要处理,剩余凭证:3
线程Thread-1 想要处理,剩余凭证:2
线程Thread-2 想要处理,剩余凭证:1
线程Thread-3 想要处理,剩余凭证:0
线程Thread-4 想要处理,剩余凭证:0
线程Thread-0 处理完毕,归还凭证!
线程Thread-1 处理完毕,归还凭证!
线程Thread-3 处理完毕,归还凭证!
线程Thread-2 处理完毕,归还凭证!
线程Thread-4 处理完毕,归还凭证!
因为凭证只有三张,3和4两个线程在一开始拿不到凭证(剩余凭证为0)会阻塞直到有线程归还后才能拿到,从而控制了并发访问的线程数量。 (理解为“抢车位”)