Java并发编程之CountDownLatch详解编程语言

CountDownLatch(闭锁)是一个很有用的工具类，利用它我们可以拦截一个或多个线程使其在某个条件成熟后再执行。

说到这，给大家举一个最典型的例子：假设一条流水线上有三个工作者：worker0，worker1，worker2。有一个任务的完成需要他们三者协作完成，worker2可以开始这个任务的前提是worker0和worker1完成了他们的工作，而worker0和worker1是可以并行他们各自的工作的。

如果使用普通的线程阻塞方式，我想大家很容易就会想到使用join的方式来做。当在当前线程中调用某个线程 thread 的 join() 方法时，当前线程就会阻塞，直到thread 执行完成，当前线程才可以继续往下执行。

如果使用这种方式编码实现的话，代码如下：

public class Worker extends Thread { 

 private String name; 

 private long time; 

 public Worker(String name, long time) { 

 this.name = name; 

 this.time = time; 

 @Override 

 public void run() { 

 try { 

 System.out.println(name+"开始工作"); 

 Thread.sleep(time); 

 System.out.println(name+"工作完成，耗费时间="+time); 

 } catch (InterruptedException e) { 

 e.printStackTrace(); 

} 

然后我们添加一个测试方法：

public class Test { 

 public static void main(String[] args) throws InterruptedException { 

 // TODO 自动生成的方法存根 

 Worker worker0 = new Worker("worker0", (long) (Math.random()*2000+3000)); 

 Worker worker1 = new Worker("worker1", (long) (Math.random()*2000+3000)); 

 Worker worker2 = new Worker("worker2", (long) (Math.random()*2000+3000)); 

 worker0.start(); 

 worker1.start(); 

 worker0.join(); //调用join阻塞worker0 

 worker1.join(); //调用join阻塞worker1 

 System.out.println("准备工作就绪"); 

 worker2.start(); 

} 

然后运行上面的代码，我们可以发现就可以满足上面的结果。

除此之外，我们还可以使用CountDownLatch来实现上面的效果，说到这就不得不说下CountDownLatch的一个实现原理。

CountDownLatch类是位于java.util.concurrent包下的一个并发工具类，是通过一个计数器来实现的，计数器的初始值为线程的数量。

每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。也就是说，构造器中的计数值（count）实际上就是闭锁需要等待的线程数量，这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。当这个CountDownLatch数量归0后，其他的线程采用执行的机会。

与CountDownLatch的第一次交互是主线程等待其他线程，主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

例如，对于文章开头的实例，要实现同样的效果，我们需要做以下的修改。

public class Worker extends Thread { 

 private String name; 

 private long time; 

 private CountDownLatch countDownLatch; 

 public Worker(String name, long time, CountDownLatch countDownLatch) { 

 this.name = name; 

 this.time = time; 

 this.countDownLatch = countDownLatch; 

 @Override 

 public void run() { 

 try { 

 System.out.println(name+"开始工作"); 

 Thread.sleep(time); 

 System.out.println(name+"工作完成，耗费时间="+time); 

 countDownLatch.countDown(); 

 System.out.println("countDownLatch.getCount()="+countDownLatch.getCount()); 

 } catch (InterruptedException e) { 

 e.printStackTrace(); 

} 

然后，我们编写一个测试用例：

 

public class Test { 

 public static void main(String[] args) throws InterruptedException { 

 CountDownLatch countDownLatch = new CountDownLatch(2); 

 Worker worker0 = new Worker("worker0", (long) (Math.random()*2000+3000), countDownLatch); 

 Worker worker1 = new Worker("worker1", (long) (Math.random()*2000+3000), countDownLatch); 

 Worker worker2 = new Worker("worker2", (long) (Math.random()*2000+3000), countDownLatch); 

 worker0.start(); 

 worker1.start(); 

 //立即调用CountDownLatch.await() 

 countDownLatch.await(); 

 System.out.println("准备工作就绪"); 

 worker2.start(); 

} 

试想以下，有下面一种应用场景：假设worker的工作可以分为两个阶段，work2 只需要等待work0和work1完成他们各自工作的第一个阶段之后就可以开始自己的工作了，而不是场景1中的必须等待work0和work1把他们的工作全部完成之后才能开始。

这种情况下，join是没办法实现这个场景的，而CountDownLatch却可以，因为它持有一个计数器，只要计数器为0，那么主线程就可以结束阻塞往下执行。相关代码如下：

public class Worker extends Thread { 

 private String name; 

 private long time; 

 private CountDownLatch countDownLatch; 

 public Worker(String name, long time, CountDownLatch countDownLatch) { 

 this.name = name; 

 this.time = time; 

 this.countDownLatch = countDownLatch; 

 @Override 

 public void run() { 

 try { 

 System.out.println(name+"开始工作"); 

 Thread.sleep(time); 

 System.out.println(name+"第一阶段工作完成"); 

 countDownLatch.countDown(); 

 Thread.sleep(2000); //这里就姑且假设第二阶段工作都是要2秒完成 

 System.out.println(name+"第二阶段工作完成"); 

 System.out.println(name+"工作完成，耗费时间="+(time+2000)); 

 } catch (InterruptedException e) { 

 e.printStackTrace(); 

}

测试方法：

public class Test { 

 public static void main(String[] args) throws InterruptedException { 

 CountDownLatch countDownLatch = new CountDownLatch(2); 

 Worker worker0 = new Worker("worker0", (long) (Math.random()*2000+3000), countDownLatch); 

 Worker worker1 = new Worker("worker1", (long) (Math.random()*2000+3000), countDownLatch); 

 Worker worker2 = new Worker("worker2", (long) (Math.random()*2000+3000), countDownLatch); 

 worker0.start(); 

 worker1.start(); 

 countDownLatch.await(); 

 System.out.println("准备工作就绪"); 

 worker2.start(); 

} 

运行上面的测试用例，可以看到满足我们条件的输出：

worker0开始工作 

worker1开始工作 

worker1第一阶段工作完成 

worker0第一阶段工作完成 

准备工作就绪 

worker2开始工作 

worker1第二阶段工作完成 

worker1工作完成，耗费时间=5521 

worker0第二阶段工作完成 

worker0工作完成，耗费时间=6147 

worker2第一阶段工作完成 

worker2第二阶段工作完成 

worker2工作完成，耗费时间=5384 

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/13024.html