Java 5 是Java 历史上非常重要的一个版本，它提供了泛型、for-each、自动装箱和拆箱、枚举、可变参数、静态导入、注解以及java.util.concurrent并发工具包，接下来简单介绍下并发工具包下的闭锁ConutDownLatch、栅栏CyclicBarrier、信号量Semaphore。

1、闭锁ConutDownLatch

java.util.concurrent.CountDownLatch 是一个并发构造，它允许一个或多个线程等待一系列指定操作的完成。CountDownLatch 以一个给定的数量初始化。countDown()每被调用一次，这一数量就减1。通过调用 await()方法，线程可以阻塞等待这一数量到达零。

示例代码如下：

import java.util.concurrent.CountDownLatch;

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正在执行

等待2个子线程执行完毕...

子线程Thread-1正在执行

子线程Thread-0执行完毕

子线程Thread-1执行完毕

2个子线程已经执行完毕

继续执行主线程

闭锁还有其他用途，例如，游戏中，需要8名玩家都准备就绪后，游戏才能开始。也可以利用闭锁计算各个线程执行完成所需的时间。

2、栅栏CyclicBarrier

CyclicBarrier 类是一种同步机制，它能对处理一些算法的线程实现同步。换句话说，它就是一个所有线程必须等待的一个栅栏，直到所有线程都到达这里，然后所有线程才可以继续做其他事情。通过调用 CyclicBarrier 对象的 await()方法，两个线程可以实现互相等待。一旦 N 个线程在等待 CyclicBarrier 达成，所有线程将被释放掉去继续执行。

示例代码如下：

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CyclicBarrierDemo {

public static void main(String[] args) {

ExecutorService service = Executors.newFixedThreadPool(5);

final CyclicBarrier barrier = new CyclicBarrier(5);

for (int i = 0; i < 5; i++) {

service.execute(new Player("玩家" + i, barrier));

}

service.shutdown();

}

}

import java.util.Random;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.TimeUnit;

public class Player implements Runnable {

private final String name;

private final CyclicBarrier barrier;

public Player(String name, CyclicBarrier barrier) {

this.name = name;

this.barrier = barrier;

}

public void run() {

try {

TimeUnit.SECONDS.sleep(1 + (new Random().nextInt(3)));

System.out.println(name + "已准备,等待其他玩家准备...");

barrier.await();

TimeUnit.SECONDS.sleep(1 + (new Random().nextInt(3)));

System.out.println(name + "已加入游戏");

} catch (InterruptedException e) {

System.out.println(name + "离开游戏");

} catch (BrokenBarrierException e) {

System.out.println(name + "离开游戏");

}

}

}

运行结果：

玩家3已准备,等待其他玩家准备...

玩家4已准备,等待其他玩家准备...

玩家2已准备,等待其他玩家准备...

玩家0已准备,等待其他玩家准备...

玩家1已准备,等待其他玩家准备...

玩家4已加入游戏

玩家1已加入游戏

玩家0已加入游戏

玩家3已加入游戏

玩家2已加入游戏

3、信号量 Semaphore

Semaphore类是一个计数信号量。这就意味着它具备两个主要方法：

● acquire()获取

● release()释放

计数信号量由一个指定数量的“许可”初始化。每调用一次 acquire()，一个许可会被调用线程取走。每调用一次 release()，一个许可会被还给信号量。因此，在没有任何 release()调用时，最多有 N 个线程能够通过 acquire()方法，N 是该信号量初始化时的许可的指定数量。

Semaphore就是一个信号量，它的作用是限制某段代码块的并发数。Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问，如果超出了n，那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入。由此可以看出如果Semaphore构造函数中传入的int型整数n=1，相当于变成了一个synchronized了。

示例代码：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

public class TestSemaphore {

private static final int THREAD_COUNT = 10;

private static ExecutorService threadPool = Executors

.newFixedThreadPool(THREAD_COUNT);

private static Semaphore s = new Semaphore(5);

public static void main(String[] args) {

for (int i = 0; i < THREAD_COUNT; i++) {

threadPool.execute(new Employee(String.valueOf(i), s));

}

threadPool.shutdown();

}

}

import java.util.Random;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

class Employee implements Runnable {

private String id;

private Semaphore semaphore;

private static Random rand= new Random(47);

public Employee(String id, Semaphore semaphore) {

this.id = id;

this.semaphore = semaphore;

}

public void run() {

try {

semaphore.acquire();

System.out.println(this.id + " is using the toilet");

TimeUnit.MILLISECONDS.sleep(rand.nextInt(2000));

System.out.println(this.id + " is leaving");

semaphore.release();

} catch (InterruptedException e) {

}

}

}

运行结果：

1 is using the toilet

0 is using the toilet

2 is using the toilet

6 is using the toilet

3 is using the toilet

1 is leaving

9 is using the toilet

2 is leaving

7 is using the toilet

3 is leaving

4 is using the toilet

9 is leaving

8 is using the toilet

4 is leaving

5 is using the toilet

0 is leaving

5 is leaving

8 is leaving

7 is leaving

6 is leaving

假设有5个semaphore(厕所)，有10个线程(员工)取占用，肯定只有5个线程(员工)能够占用，每当一个线程(员工) 使用完(release) ，会有另一个线程占用(acquire) 。可用来控制线程并发数，比如数据库连接等。

总结：

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

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再继续执行；

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

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