Java并发编程工具类 CountDownLatch CyclicBarrier Semaphore使用Demo
CountDownLatch
countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
CountDownLatch中的方法
//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };
//将count值减1
public void countDown() { };
CountDownLatchDemo
条件改为i<20时，并不会输出“完结撒花”，因为latch还没有减到0
import java.util.concurrent.CountDownLatch;public class CountDownLatchDemo {
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(20);
//条件改为i<20时，并不会输出“完结撒花”，因为latch还没有减到0
for (int i = 0; i < 20; i++) {
int index=i;
new Thread(new Runnable() {
@Override
public void run() {
latch.countDown();
System.out.println(index);
}
}).start();
}
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("完结撒花");
}
}
CyclicBarrier
CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用。
- CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
构造方法
public CyclicBarrier(int parties)
public CyclicBarrier(int parties, Runnable barrierAction)
- parties 是参与线程的个数
- 第二个构造方法有一个 Runnable 参数，这个参数的意思是最后一个到达线程要做的任务
方法
public int await() throws InterruptedException, BrokenBarrierException
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException
- 线程调用 await() 表示自己已经到达栅栏
- BrokenBarrierException 表示栅栏已经被破坏，破坏的原因可能是其中一个线程 await() 时被中断或者超时
Demo
- 初始化线程1，线程1睡眠3秒
- 剩余九个线程到达barrier,但是并不会又输出
- 三秒后线程1到达，9个线程开始输出
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(10);
//初始化线程1，线程1睡眠3秒，等待剩余九个线程到达barrier
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}).start();
//九个线程先到达barrier
for (int i = 0; i < 9; i++) {
int index=i;
new Thread(new Runnable() {
@Override
public void run() {
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(index);
}
}).start();
}
}
}
//Output,输出是随机的
/*
0
6
2
1
8
7
4
3
5*/
Semaphore
Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。
常用方法
void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。 void release():释放一个许可，将其返回给信号量。 int availablePermits():返回此信号量中当前可用的许可数。 boolean hasQueuedThreads():查询是否有线程正在等待获取。Demo
- 六个人竞争三个办事窗口，每个办事窗口只能容纳三个人，输出如下
package ConcurrentApi;import java.util.concurrent.Semaphore;
//Output
/*
线程0等到了办事窗口空闲
办事窗口剩余量2
线程1等到了办事窗口空闲
办事窗口剩余量1
线程2等到了办事窗口空闲
办事窗口剩余量0
线程3等到了办事窗口空闲
办事窗口剩余量0
线程4等到了办事窗口空闲
办事窗口剩余量0
线程5等到了办事窗口空闲
办事窗口剩余量0*/
public class SemaphoreDemo {
public static void main(String[] args) {
//初始化3 三个办事窗口
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 6; i++) {
int index = i;
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(new Runnable() {
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("线程"+index+"等到了办事窗口空闲");
System.out.println("办事窗口剩余量"+semaphore.availablePermits());
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.currentThread().sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
semaphore.release();
}
}).start();
}
}
}
