首页 > 代码库 > Java多线程与并发库高级应用之倒计时计数器

Java多线程与并发库高级应用之倒计时计数器

2024-07-02 06:08:28   227人阅读

CountDownLatch 类是一个倒计时计数器，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数初始化 CountDownLatch。由于调用了countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
CountDownLatch 是一个通用同步工具，它有很多用途。将计数1初始化的 CountDownLatch 用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await 的线程都一直在入口处等待。用N初始化的 CountDownLatch 可以使一个线程在N个线程完成某项操作之前一直等待，或者使其在某项操作完成N次之前一直等待。
CountDownLatch犹如比赛的发令官，多条线程犹如运动员。倒计时到零时一声枪响，运动员开始比赛，即多条线程开始运行。

使用CountDownLatch很简单，因为它只提供了一个构造器：
CountDownLatch(int count)：构造一个用给定计数初始化的CountDownLatch。

在线程中调用CountDownLatch对象的await()方法，会使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。而调用countDown()方法会递减锁存器的计数，如果计数到达零，则释放所有等待的线程。

见下面程序：启动三个线程等待主线程发布命令，主线程发布命令后等待三个线程运行完后的反馈。
[java] view plaincopy
  1. public class CountDownLatchDemo {  
  2.   
  3.     public static void main(String[] args) {  
  4.           
  5.         //线程池  
  6.         ExecutorService pool = Executors.newCachedThreadPool();  
  7.         //定义两个倒计时计数器  
  8.         //等待命令倒计时计数器  
  9.         final CountDownLatch countOrder = new CountDownLatch(1);  
  10.         //等待反馈倒计时计数器  
  11.         final CountDownLatch countAnswer = new CountDownLatch(3);  
  12.           
  13.         //3个子线程  
  14.         for(int i = 0; i < 3; i++){  
  15.             Runnable target = new Runnable() {  
  16.                 @Override  
  17.                 public void run() {  
  18.                     try {  
  19.                         System.out.println(Thread.currentThread().getName() +   
  20.                                 "-等待命令");  
  21.                         //等待countOrder为0时停止等待，向下执行  
  22.                         countOrder.await();  
  23.                           
  24.                         System.out.println(Thread.currentThread().getName() +   
  25.                                 "-得到命令，开始执行");  
  26.                         Thread.sleep((long)(Math.random()*10000));  
  27.                         System.out.println(Thread.currentThread().getName() +   
  28.                                 "-命令执行完成，回应结果");  
  29.                         //将countAnswer减一  
  30.                         countAnswer.countDown();  
  31.                     } catch (InterruptedException e) {  
  32.                         e.printStackTrace();  
  33.                     }  
  34.                       
  35.                 }  
  36.             };  
  37.             pool.execute(target);  
  38.         }  
  39.           
  40.         //主线程  
  41.         try{  
  42.             Thread.sleep((long)(Math.random()*10000));  
  43.             System.out.println(Thread.currentThread().getName() +   
  44.                     "-即将发布命令");  
  45.             //将countOrder减一  
  46.             countOrder.countDown();  
  47.             System.out.println(Thread.currentThread().getName() +   
  48.                     "-已发布命令，等待回应");  
  49.             //等待回应  
  50.             countAnswer.await();  
  51.             System.out.println(Thread.currentThread().getName() +   
  52.                     "-已收到所有回应结果");  
  53.         }catch(InterruptedException e) {  
  54.             e.printStackTrace();  
  55.         }  
  56.           
  57.         pool.shutdown();  
  58.     }  
  59.   
  60. }  

运行程序


看到3个子线程在接到主线程命令前都等待，当主线程调用了countDown() 方法后减为零，3个子线程开始运行，并且主线程等待子线程运行完后的回应。3个子线程没运行完一个调用countDown() 方法，当3个都运行完后，主线程收到回应。


联系
我们