线程状态控制 CountDownLatch和CyclicBarrier的区别

最新推荐文章于 2025-06-15 21:17:15 发布

转载最新推荐文章于 2025-06-15 21:17:15 发布 · 632 阅读

文章标签：

#CountDownLatch #CyclicBarrier #线程状态控制 thread流程控制

JAVA 专栏收录该内容

37 篇文章

订阅专栏

本文详细解析了CountDownLatch和CyclicBarrier两种同步工具的区别。CountDownLatch适用于一个线程等待多个线程完成任务；而CyclicBarrier则用于一组线程相互等待，直到所有线程到达指定屏障点。

在网上看到很多人对于CountDownLatch和CyclicBarrier的区别简单理解为CountDownLatch是一次性的，而CyclicBarrier在调用reset之后还可以继续使用。那如果只是这么简单的话，我觉得CyclicBarrier简单命名为ResetableCountDownLatch好了，显然不是的。
我的理解是，要从他们的设计目的去看这两个类。javadoc里面的描述是这样的。

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

可能是我的英语不够好吧，我感觉从这个javadoc里面要准确理解他们的差异还是不容易的。
我的理解是

CountDownLatch : 一个线程(或者多个)，等待另外N个线程完成某个事情之后才能执行。 CyclicBarrier : N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。
这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待，而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。

CountDownLatch 是计数器, 线程完成一个就记一个, 就像报数一样, 只不过是递减的.

而CyclicBarrier更像一个水闸, 线程执行就想水流, 在水闸处都会堵住, 等到水满(线程到齐)了, 才开始泄流.

package concurrent;
import java.util.Random;  
    import java.util.concurrent.CountDownLatch;  
    import java.util.concurrent.TimeUnit;  
      
    public class Worker implements Runnable{  
          
        private CountDownLatch downLatch;  
        private String name;  
          
        public Worker(CountDownLatch downLatch, String name){  
            this.downLatch = downLatch;  
            this.name = name;  
        }  
          
        public void run() {  
            this.doWork();  
            try{  
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));  
            }catch(InterruptedException ie){  
            }  
            System.out.println(this.name + "活干完了！");  
            this.downLatch.countDown();  
              
        }  
          
        private void doWork(){  
            System.out.println(this.name + "正在干活!");  
        }  
          
    }

package concurrent;
 import java.util.concurrent.CountDownLatch;  
      
    public class Boss implements Runnable {  
      
        private CountDownLatch downLatch;  
          
        public Boss(CountDownLatch downLatch){  
            this.downLatch = downLatch;  
        }  
          
        public void run() {  
            System.out.println("老板正在等所有的工人干完活......");  
            try {  
                this.downLatch.await();  
            } catch (InterruptedException e) {  
            }  
            System.out.println("工人活都干完了，老板开始检查了！");  
        }  
      
    }

package concurrent;
import java.util.concurrent.CountDownLatch;  
    import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
      
    public class CountDownLatchDemo {  
      
        public static void main(String[] args) {  
            ExecutorService executor = Executors.newCachedThreadPool();  
              
            CountDownLatch latch = new CountDownLatch(1);  
              
            Worker w1 = new Worker(latch,"张三1111");  
              
            Boss boss = new Boss(latch);  
              
            executor.execute(w1);  
            executor.execute(boss);  
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            
            
            CountDownLatch latch1 = new CountDownLatch(1);  
            Worker w4 = new Worker(latch1,"张三");  
              
            Boss boss1 = new Boss(latch1);  
            executor.execute(w4);  
            executor.execute(boss1);  
            
            executor.shutdown();  
            
            
            
        }  
      
    }