java并发之CountDownLatch

CountDownLatch是java同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数num赋予CountDownLatch的构造函数，表示需要同步这num个线程，当这些线程运行到同步点时，对CountDownLatch调用CountDown()方法，使得num-1，当num减为0时，表示所有需要同步的线程均到达同步点，此时被CountDownLatch的await()方法阻塞的线程开始执行。

CountDownLatch是闭锁的一种实现，闭锁是一种同步工具类，可以延迟线程的进度直到其到达终止状态。它的作用相当于一扇门：在闭锁到达结束状态之前，这扇门始终是关闭的，而且没有任何线程可以通过，当到达结束状态时，这扇门就会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开状态。闭锁可以用来确保某些活动都完成后才继续执行，比如：

　　1.确保某个计算在其需要的所有资源都被初始化之后才继续执行。二元闭锁（包括两个状态）可以用来表示“资源R已经被初始化”，而所有需要R的操作都必须在这个闭锁上等待。

　　2.确保某个服务在其依赖的所有其它服务都已经启动之后才启动。每个服务都有一个相关的二元闭锁。当启动服务s时，将首先在s依赖的其它服务的闭锁上等待，在所有依赖的服务都启动后会释放闭锁s，这样其它依赖s的服务才能继续执行。

　　3.等待直到某个操作的所有参与者（比如，在多玩家游戏中的所有玩家）都就绪再继续执行。在这种情况中，当所有玩家都准备就绪时，闭锁将到达结束状态。

下面是一个示例程序，这个程序计算四个数的和：

思路是把四个数分为两组，分别计算和，然后再对两组的和进行求和，代码如下：

package com.test;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
static class Worker extends Thread{
private CountDownLatch count;
private int left;
private int right;
private int result;
public Worker(CountDownLatch count, int left,int right) {
this.count = count;
this.left = left;
this.right = right;
}

@Override
public void run() {
synchronized(count){
System.out.print(Thread.currentThread().getName()+" : ");
result = left+right;
System.out.println("Partial result: "+result);
count.countDown();
}
}

public int getResult(){
return result;
}
}

public static void main(String[] args) throws Exception {	//计算1+2+3+4
CountDownLatch latch = new CountDownLatch(2);
Worker worker = new Worker(latch,1,2);
Worker worker2 = new Worker(latch,3,4);
worker.start();
worker2.start();

System.out.println("Main waiting!!");
latch.await();
System.out.println("Waiting end,Result is: "+(worker.getResult()+worker2.getResult()));
}
}

使用FutureTask的代码：

package com.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class Worker implements Callable<Integer> {
private int hours = 12;
private int amount;

@Override
public Integer call() throws Exception {
while(hours>0){
amount++;
System.out.println("I'm working......"+amount);
hours--;
Thread.sleep(100);
}
return amount;
}

}

public class FutureTaskTest {
public static void main(String[] args) {
Worker worker = new Worker();
FutureTask<Integer> boss = new FutureTask<Integer>(worker);
new Thread(boss).start();
//System.out.println("hello");
//System.out.println(boss.isDone());
while(!boss.isDone()){
try {
System.out.println("看工人做完了没..........");
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
int amount;
try{
amount = boss.get();
System.out.println("工作完成"+amount);
}catch(InterruptedException e){
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}