CountDownLatch、CyclicBarrier和Semaphore这三个并发辅助类，可以在线程中呼叫，使得线程暂停等，但各有不同。
1、初始化，并传入计数器
2、向不同的线程传入CountDownLatch实例
3、如果在某一线程中呼叫await()，则此线程被挂起，直到计数器为0，才往下执行
4、如果在某一线程中呼叫countDown()，计数器减1
5、最终如果计数器值为0时，则CountDownLatch实例不再起作用了，即为一次性的
1、初始化，并传入计数器值，也可传入一个Runnable类，会在计数器为0时，被执行
2、向不同的线程传入CyclicBarrier实例
3、如果在某一线程中呼叫await()，则此线程被挂起，直到计数器为0，才往下执行
4、其他线程呼叫await()，则此线程被挂起，直到计数器为0，才往下执行
5、最终如果计数器值为0时，则CyclicBarrier实例会将计数器值恢复，又可重用
1、初始化，并传入计数器值
2、向不同的线程传入Semaphore实例
3、如果在某一线程中呼叫acquire()，则Semaphore实例会将计数器值减1，如果计数器值为-1，则将计数器值置为0，此线程被挂起，直到计数器值大于1时，才往下执行
4、此线程需呼叫release()，使得计数器值+1，以便其他线程在计数器值为0时不受阻
CountDownLatch 例子：
public class Test {
public static void main(String[] args) {
final CountDownLatch latch =
new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
}
catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
}
catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
System.out.println("等待2个子线程执行完毕
");
latch.await();
System.out.println("2个子线程已经执行完毕");
System.out.println("继续执行主线程");
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果：
线程Thread-0正在执行
线程Thread-1正在执行
等待2个子线程执行完毕
线程Thread-0执行完毕
线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程
CyclicBarrier例子：
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier =
new CyclicBarrier(N,
new Runnable() {
@Override
public void run() {
System.out.println("当前线程"+Thread.currentThread().getName());
}
});
for(
int i=0;i<N;i++)
new Writer(barrier).start();
}
static class Writer
extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据
");
try {
Thread.sleep(5000);
//以睡眠来模拟写入数据操作
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
cyclicBarrier.await();
}
catch (InterruptedException e) {
e.printStackTrace();
}
catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有线程写入完毕，继续处理其他任务
");
}
}
}
执行结果：
线程Thread-0正在写入数据
线程Thread-1正在写入数据
线程Thread-2正在写入数据
线程Thread-3正在写入数据
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
当前线程Thread-3
所有线程写入完毕，继续处理其他任务
所有线程写入完毕，继续处理其他任务
所有线程写入完毕，继续处理其他任务
所有线程写入完毕，继续处理其他任务
Semaphore例子：
public class Test {
public static void main(String[] args) {
int N = 8;
//工人数
Semaphore semaphore =
new Semaphore(5);
//机器数目
for(
int i=0;i<N;i++)
new Worker(i,semaphore).start();
}
static class Worker
extends Thread{
private int num;
private Semaphore semaphore;
public Worker(
int num,Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("工人"+
this.num+"占用一个机器在生产
");
Thread.sleep(2000);
System.out.println("工人"+
this.num+"释放出机器");
semaphore.release();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
执行结果：
工人0占用一个机器在生产
工人1占用一个机器在生产
工人2占用一个机器在生产
工人4占用一个机器在生产
工人5占用一个机器在生产
工人0释放出机器
工人2释放出机器
工人3占用一个机器在生产
工人7占用一个机器在生产
工人4释放出机器
工人5释放出机器
工人1释放出机器
工人6占用一个机器在生产
工人3释放出机器
工人7释放出机器
工人6释放出机器