Java并发编程-同步辅助类之CountDownLatch

最新推荐文章于 2024-09-06 23:08:06 发布

转载最新推荐文章于 2024-09-06 23:08:06 发布 · 189 阅读

java基本概念详解专栏收录该内容

20 篇文章

订阅专栏

本文介绍了CountDownLatch类的基本概念和使用方法，包括构造函数、await()、countDown()等方法的作用及应用场景。并通过两个实例演示了如何利用CountDownLatch来协调线程间的同步执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

操作方法

构造函数CountDownLatch(int count)，count表示要等待的操作数的数目。
await()方法，阻塞等待，需要其他线程完成期待的操作，直到count为0。
countDown()方法，当某一个操作完成后，调用此方法，count数减一。

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量，此值是线程将要等待的操作数（线程的数量）。当某个线程为了想要执行这些操作而等待时，它要使用 await()方法。此方法让线程进入休眠直到操作完成。当某个操作结束，它使用countDown() 方法来减少CountDownLatch类的内部计数器，计数器的值就会减1。当计数器到达0时，它表示所有的线程已经完成了任务，这个类会唤醒全部使用await() 方法休眠的线程们恢复执行任务。

注意

一个countDownLatch的作用只能使用一次，当counDownLatch对象的计数器被初始化之后不能再次初始化或者修改。当调用countDown()方法使count为0时，await()方法阻塞的线程都会被唤醒执行，之后再使用countDown()等方法已经没有用了，CountDownLatch对象也就没有用了。

与Semaphore类或者lock类不同，CountDownLatch类不能保护共享数据，因为它不提供互斥访问，它是用来同步执行多个任务或者线程。

单个CountDownLatch

只控制所有线程方法都完成后再执行其他操作

下面看一个例子大家就清楚CountDownLatch的用法了：

public class Test {
     public static void main(String[] args) {   
         final CountDownLatch latch = new CountDownLatch(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正在执行
线程Thread-1正在执行
等待2个子线程执行完毕...
线程Thread-0执行完毕
线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程

2个CountDownLatch

一个用于控制等所有线程方法都准备好以后“同时开启”，一个用于控制所有线程都结束后再继续后续的操作

使用实例

package MyThread;
import java.util.concurrent.CountDownLatch;
public class Match {

    // 模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。
    public static void main(String[] args) throws InterruptedException {

        // 开始的倒数锁 
        final CountDownLatch begin=new CountDownLatch(1) ;  
        // 结束的倒数锁 
        final CountDownLatch end=new CountDownLatch(10);  
        // 十名选手 

        for (int index = 0; index < 10; index++) {
            new Thread(new player(begin, end),"player"+index).start();
        }  
        System.out.println("Game Start");  
        // begin减1，计算变为0，开始游戏
        begin.countDown();  
        // 等待end变为0，即所有选手到达终点
        end.await();  
        System.out.println("Game Over");  

    }
}
class player implements Runnable{
    // 开始的倒数锁 
    private  final CountDownLatch begin ;  
    // 结束的倒数锁 
    private final CountDownLatch end;  

    player(CountDownLatch begin,CountDownLatch end){
        this.begin=begin;
        this.end=end;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {  
            // 如果当前计数为零，则此方法立即返回。
            // 等待
            begin.await();  
            Thread.sleep((long) (Math.random() * 10000));  
            System.out.println(Thread.currentThread().getName() + " arrived");  
        } catch (InterruptedException e) { 
            e.printStackTrace();          
        } finally {  
            // 每个选手到达终点时，end就减一
            end.countDown();
        }
    }
}

结果
Game Start
player7 arrived
player2 arrived
player3 arrived
player6 arrived
player4 arrived
player0 arrived
player9 arrived
player1 arrived
player5 arrived
player8 arrived
Game Over