Java并发编程：CountDownLatch、CyclicBarrier和Semaphore

在java 1.5中，提供了一些非常有用的辅助类来帮助我们进行并发编程，比如CountDownLatch，CyclicBarrier和Semaphore。

一.CountDownLatch用法

　　CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

CountDownLatch类只提供了一个构造器：

public CountDownLatch(int count) {  };  //参数count为计数值

三个重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

看一个例子：

public class Test {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2); //计数值为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个子线程已经执行完毕
继续执行主线程

CountDownLatch主要提供的机制是当多个（具体数量等于初始化CountDownLatch时count参数的值）线程都达到了预期状态或完成预期工作时触发事件，其他线程可以等待这个事件来触发自己的后续工作。值得注意的是，CountDownLatch是可以唤醒多个等待的线程的。

到达自己预期状态的线程会调用CountDownLatch的countDown方法，等待的线程会调用CountDownLatch的await方法。如果CountDownLatch初始化的count值为1，那么这就退化为一个单一事件了，即是由一个线程来通知其他线程，效果等同于对象的wait和notifyAll；count值大于1是常用的方式，目的是为了让多个线程到达各自的预期状态，变为一个事件进行通知，线程则继续自己的行为。

二.CyclicBarrier用法

CyclicBarrier从字面理解是指循环屏障，它可以协同多个线程，让多个线程在这个屏障前等待，直到所有线程都达到了这个屏障时，再一起继续执行后面的动作。看一下CyclicBarrier的使用实例：

public static class CyclicBarrierThread extends Thread
{
private CyclicBarrier cb;
private int sleepSecond;

public CyclicBarrierThread(CyclicBarrier cb, int sleepSecond)
{
this.cb = cb;
this.sleepSecond = sleepSecond;
}

public void run()
{
try
{
System.out.println(this.getName() + "运行了");
Thread.sleep(sleepSecond * 1000);
System.out.println(this.getName() + "准备等待了, 时间为" + System.currentTimeMillis());
cb.await(); //挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务
System.out.println(this.getName() + "结束等待了, 时间为" + System.currentTimeMillis());
}
catch (Exception e)
{
e.printStackTrace();
}
}
}

public static void main(String[] args)
{
Runnable runnable = new Runnable()
{
public void run()
{
System.out.println("CyclicBarrier的所有线程await()结束了，我运行了, 时间为" + System.currentTimeMillis());
}
};
CyclicBarrier cb = new CyclicBarrier(3, runnable); //参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容
CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3);
CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6);
CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9);
cbt0.start();
cbt1.start();
cbt2.start();
}

Thread-0运行了
Thread-2运行了
Thread-1运行了
Thread-0准备等待了, 时间为1444650316313
Thread-1准备等待了, 时间为1444650319313
Thread-2准备等待了, 时间为1444650322313
CyclicBarrier的所有线程await()结束了，我运行了, 时间为1444650322313
Thread-2结束等待了, 时间为1444650322313
Thread-0结束等待了, 时间为1444650322313
Thread-1结束等待了, 时间为1444650322313

从运行结果看，由于是同一个CyclicBarrier，Thread-0先运行到了await()的地方，等着；Thread-2接着运行到了await()的地方，还等着；Thread-1最后运行到了await()的地方，所有的线程都运行到了await()的地方，所以三个线程以及指定的Runnable”同时”运行后面的代码，可以看到，await()之后，四个线程运行的时间一模一样，都是1444650322313。

从使用来看，可能有人觉得CyclicBarrier和CountDownLatch有点像，都是多个线程等待相互完成之后，再执行后面的代码。实际上，CountDownLatch和CyclicBarrier都是用于多个线程间的协调的，它们二者的几个差别是：

1、CountDownLatch是在多个线程都进行了latch.countDown()后才会触发事件，唤醒await()在latch上的线程，而执行countDown()的线程，执行完countDown()后会继续自己线程的工作；CyclicBarrier是一个栅栏，用于同步所有调用await()方法的线程，并且等所有线程都到了await()方法时，这些线程才一起返回继续各自的工作

2、另外CountDownLatch和CyclicBarrier的一个差别是，CountDownLatch不能循环使用，计数器减为0就减为0了，不能被重置，CyclicBarrier可以循环使用

3、CountDownLatch可以唤起多条线程的任务，CyclicBarrier只能唤起一条线程的任务

三.Semaphore用法

Semaphore是非常有用的一个组件，它相当于是一个并发控制器，是用于管理信号量的。构造的时候传入可供管理的信号量的数值，这个数值就是控制并发数量的，我们需要控制并发的代码，执行前先通过acquire方法获取信号，执行后通过release归还信号 。每次acquire返回成功后，Semaphore可用的信号量就会减少一个，如果没有可用的信号，acquire调用就会阻塞，等待有release调用释放信号后，acquire才会得到信号并返回。

Semaphore分为单值和多值两种：

1、单值的Semaphore管理的信号量只有1个，该信号量只能被1个，只能被一个线程所获得，意味着并发的代码只能被一个线程运行，这就相当于是一个互斥锁了

2、多值的Semaphore管理的信号量多余1个，主要用于控制并发数

public static void main(String[] args)
{
final Semaphore semaphore = new Semaphore(5);

Runnable runnable = new Runnable()
{
public void run()
{
try
{
semaphore.acquire();
　　　　　　　　  System.out.println(Thread.currentThread().getName() + "获得了信号量,时间为" + System.currentTimeMillis());
Thread.sleep(2000);
　　　　　　　　  System.out.println(Thread.currentThread().getName() + "释放了信号量,时间为" + System.currentTimeMillis());
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally
{
semaphore.release();
}
}
};

Thread[] threads = new Thread[10];
for (int i = 0; i < threads.length; i++)
threads[i] = new Thread(runnable);
for (int i = 0; i < threads.length; i++)
threads[i].start();
}

1 Thread-1获得了信号量,时间为1444557040464
2 Thread-2获得了信号量,时间为1444557040465
3 Thread-0获得了信号量,时间为1444557040464
4 Thread-3获得了信号量,时间为1444557040465
5 Thread-4获得了信号量,时间为1444557040465
6 Thread-2释放了信号量,时间为1444557042466
7 Thread-4释放了信号量,时间为1444557042466
8 Thread-0释放了信号量,时间为1444557042466
9 Thread-1释放了信号量,时间为1444557042466
10 Thread-3释放了信号量,时间为1444557042466
11 Thread-9获得了信号量,时间为1444557042467
12 Thread-7获得了信号量,时间为1444557042466
13 Thread-6获得了信号量,时间为1444557042466
14 Thread-5获得了信号量,时间为1444557042466
15 Thread-8获得了信号量,时间为1444557042467
16 Thread-9释放了信号量,时间为1444557044467
17 Thread-6释放了信号量,时间为1444557044467
18 Thread-7释放了信号量,时间为1444557044467
19 Thread-5释放了信号量,时间为1444557044468
20 Thread-8释放了信号量,时间为1444557044468

最后注意两点：

1、Semaphore可以指定公平锁还是非公平锁

2、acquire方法和release方法是可以有参数的，表示获取/返还的信号量个数

下面对上面说的三个辅助类进行一个总结：

　　1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

　　　　CountDownLatch一般用于某个（可以是多个）线程A等待若干个其他线程执行完任务之后(等待多个线程到达某个状态)，它才执行；

　　　　而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行，并可以唤醒一个线程A；

　　　　另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

　　2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。