CountDownLatch 使用说明及内部原理

转自: https://www.cnblogs.com/cuglkb/p/8572239.html

CountDownLatch是一种java.util.concurrent包下一个同步工具类，它允许一个或多个线程等待直到在其他线程中一组操作执行完成。

CountDownLatch的用法非常简单，下面的例子也是我在网上看到的，十分贴切，这里就贴出来

public class Test {

    public static void main(String[] args) {
       CountDownLatch begin = new CountDownLatch(1);
       CountDownLatch end = new CountDownLatch(2);

       for(int i=0; i<2; i++){
           Thread thread = new Thread(new Player(begin,end));
           thread.start();
       }

       try{
           System.out.println("the race begin");
           begin.countDown();
           end.await();
           System.out.println("the race end");
       }catch(Exception e){
            e.printStackTrace();
       }

    }
}


/**
 * 选手
 */
class Player implements Runnable{

    private CountDownLatch begin;

    private CountDownLatch end;

    Player(CountDownLatch begin,CountDownLatch end){
        this.begin = begin;
        this.end = end;
    }

    public void run() {
        
        try {
            begin.await();
            System.out.println(Thread.currentThread().getName() + " arrived !");;
            end.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

下面是运行结果

可以看到 通过CountDownLatch 的使用我们控制了线程的执行顺序。

在上面代码中，我们使用到await()方法和 countDown() 方法。我们验证一下它们各自的作用。

首先验证await() 方法。将main方法中的 end.await() 注释掉，下面是注释掉后的运行结果

可以看到主线程没有等待代表选手的线程结束，直接宣布比赛结束了！刚开始就结束的比赛- -

这里可以看出，await() 方法具有阻塞作用

其次我们来验证countDown方法，将代表选手线程中的 end.countDown() 进行注释，下面是运行结果

程序一直在运行，所有选手都已经到了终点，但是裁判就是不宣传比赛结束，他在等什么呢？

我们猜测countDown() 方法具有唤醒阻塞线程的作用。

那我们也许会问，既然有唤醒阻塞线程的作用，那么我们只调用一次countDown() 方法不就是可以唤醒被阻塞的主线程了吗？

我们试一下，取消上面coutDown()的注释，再次创建一个选手，代码如下

  class Player2 implements Runnable{

        private CountDownLatch begin;

        private CountDownLatch end;

        Player2(CountDownLatch begin,CountDownLatch end){
            this.begin = begin;
            this.end = end;
        }

        public void run() {
            
            try {
                begin.await();
                System.out.println(Thread.currentThread().getName() + " arrived !");
//                end.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

main 方法也修改如下，创建了两个不同的选手

public static void main(String[] args)
    {
        CountDownLatch begin = new CountDownLatch(1);
        CountDownLatch end = new CountDownLatch(2);
        
        Thread thread = new Thread(new Player(begin, end));
        thread.start();
        
        Thread thread2 = new Thread(new Player2(begin, end));
        thread2.start();
        
        try
        {
            System.out.println("the race begin");
            begin.countDown();
            end.await();
            System.out.println("the race end");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        
    }

运行一下，下面是结果

主程序一直阻塞，没有被唤醒，裁判上厕所上得有点久啊！

这样看来countDown() 并不是直接唤醒线程，有点像一个计数器，倒计时的那种。

查看API文档，果然，我们在构造函数中添加了参数2，就需要调用 2 次 countDown() 才能将 end.await() 阻塞的线程唤醒。

CountDownLatch end = new CountDownLatch(2);

总结一下，

　　1、CountDownLatch end = new CountDownLatch(N); //构造对象时候需要传入参数N

　　2、end.await() 能够阻塞线程直到调用N次end.countDown() 方法才释放线程

　　3、end.countDown() 可以在多个线程中调用计算调用次数是所有线程调用次数的总和

CountDownLatch实现原理及使用姿势

转自: https://cloud.tencent.com/developer/article/1038486

在并发编程的场景中，最常见的一个case是某个任务的执行，需要等到多个线程都执行完毕之后才可以进行，CountDownLatch可以很好解决这个问题

下面将主要从使用和实现原理两个方面进行说明，围绕点如下

CountDownLatch 是个什么鬼
怎么用（结合case说明）
底层实现原理（及如何保障功能的正常性）

I. 使用说明

同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

比较有意思的是，CountDownLatch并未继承自其他的类or接口，在jdk中这样的类并不多见（多半是我孤陋寡闻）

0. 接口定义

在使用之前，得先了解下其定义的几个方法

// 构造器，必须指定一个大于零的计数
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

// 线程阻塞，直到计数为0的时候唤醒；可以响应线程中断退出阻塞
public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

// 线程阻塞一段时间，如果计数依然不是0，则返回false；否则返回true
public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

// 计数-1
public void countDown() {
    sync.releaseShared(1);
}

// 获取计数
public long getCount() {
    return sync.getCount();
}

也就几个接口，基本上都是比较常见的了，需要注意的是不要把 await()和 Object#wait()方法弄混了，否则就gg思密达了...

1. Demo演示

依然以讲解 ReentrantLock中的例子来说明，多线程实现累加

线程1实现 10加到100
线程2实现 100加到200
线程3实现 线程1和线程2计算结果的和

实现如下

public class CountDownLatchDemo {
    private CountDownLatch countDownLatch;

    private int start = 10;
    private int mid = 100;
    private int end = 200;

    private volatile int tmpRes1, tmpRes2;

    private int add(int start, int end) {
        int sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }


    private int sum(int a, int b) {
        return a + b;
    }

    public void calculate() {
        countDownLatch = new CountDownLatch(2);

        Thread thread1 = new Thread(() -> {
            try {
                // 确保线程3先与1，2执行，由于countDownLatch计数不为0而阻塞
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " : 开始执行");
                tmpRes1 = add(start, mid);
                System.out.println(Thread.currentThread().getName() +
                        " : calculate ans: " + tmpRes1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                countDownLatch.countDown();
            }
        }, "线程1");

        Thread thread2 = new Thread(() -> {
            try {
                // 确保线程3先与1，2执行，由于countDownLatch计数不为0而阻塞
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " : 开始执行");
                tmpRes2 = add(mid + 1, end);
                System.out.println(Thread.currentThread().getName() +
                        " : calculate ans: " + tmpRes2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                countDownLatch.countDown();
            }
        }, "线程2");


        Thread thread3 = new Thread(()-> {
            try {
                System.out.println(Thread.currentThread().getName() + " : 开始执行");
                countDownLatch.await();
                int ans = sum(tmpRes1, tmpRes2);
                System.out.println(Thread.currentThread().getName() +
                        " : calculate ans: " + ans);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程3");

        thread3.start();
        thread1.start();
        thread2.start();
    }


    public static void main(String[] args) throws InterruptedException {
        CountDownLatchDemo demo = new CountDownLatchDemo();
        demo.calculate();

        Thread.sleep(1000);
    }
}

输出

线程3 : 开始执行
线程1 : 开始执行
线程2 : 开始执行
线程1 : calculate ans: 5005
线程2 : calculate ans: 15050
线程3 : calculate ans: 20055

看了上面的定义和Demo之后，使用就会简单一点了，一般流程如

首先是创建实例 CountDownLatch countDown = new CountDownLatch(2)
需要同步的线程执行完之后，计数-1； countDown.countDown()
需要等待其他线程执行完毕之后，再运行的线程，调用 countDown.await()实现阻塞同步

注意

在创建实例是，必须指定初始的计数值，且应大于0
必须有线程中显示的调用了countDown()计数-1方法；必须有线程显示调用了 await()方法（没有这个就没有必要使用CountDownLatch了）
由于await()方法会阻塞到计数为0，如果在代码逻辑中某个线程漏掉了计数-1，导致最终计数一直大于0，直接导致死锁了
鉴于上面一点，更多的推荐 await(long, TimeUnit)来替代直接使用await()方法，至少不会造成阻塞死只能重启的情况

有兴趣的小伙伴可以对比下这个实现与《Java并发学习之ReentrantLock的工作原理及使用姿势》中的demo，明显感觉使用CountDownLatch优雅得多（后面有机会介绍用更有意思的Fork/Join来实现累加）

2. 应用场景

前面给了一个demo演示如何用，那这个东西在实际的业务场景中是否会用到呢？

因为确实在一个业务场景中使用到了，不然也就不会单独捞出这一节...

电商的详情页，由众多的数据拼装组成，如可以分成一下几个模块

交易的收发货地址，销量
商品的基本信息（标题，图文详情之类的）
推荐的商品列表
评价的内容
....

上面的几个模块信息，都是从不同的服务获取信息，且彼此没啥关联；所以为了提高响应，完全可以做成并发获取数据，如

线程1获取交易相关数据
线程2获取商品基本信息
线程3获取推荐的信息
线程4获取评价信息
....

但是最终拼装数据并返回给前端，需要等到上面的所有信息都获取完毕之后，才能返回，这个场景就非常的适合 CountDownLatch来做了

在拼装完整数据的线程中调用 CountDownLatch#await(long, TimeUnit) 等待所有的模块信息返回
每个模块信息的获取，由一个独立的线程执行；执行完毕之后调用 CountDownLatch#countDown() 进行计数-1

II. 实现原理

同ReentrantLock一样，依然是借助AQS的双端队列，来实现原子的计数-1，线程阻塞和唤醒

前面《Java并发学习之ReentrantLock的工作原理及使用姿势》介绍了AQS的结构，方便查看，下面直接贴出

0. AbstractQueuedSynchronizer （简称AQS）

AQS是一个用于构建锁和同步容器的框架。事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时设计的大量细节问题

AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus

private transient volatile Node head;

private transient volatile Node tail;

private volatile int state;

static final class Node {
    static final Node SHARED = new Node();
    static final Node EXCLUSIVE = null;

    /** waitStatus value to indicate thread has cancelled */
    static final int CANCELLED =  1;
    /** waitStatus value to indicate successor's thread needs unparking */
    static final int SIGNAL    = -1;
    /** waitStatus value to indicate thread is waiting on condition */
    static final int CONDITION = -2;
    /**
     * waitStatus value to indicate the next acquireShared should
     * unconditionally propagate
     */
    static final int PROPAGATE = -3;

    //取值为 CANCELLED, SIGNAL, CONDITION, PROPAGATE 之一
    volatile int waitStatus;

    volatile Node prev;

    volatile Node next;

    // Link to next node waiting on condition, 
    // or the special value SHARED
    volatile Thread thread;

    Node nextWaiter;
}

1. 计数器的初始化

CountDownLatch内部实现了AQS，并覆盖了tryAcquireShared()和tryReleaseShared()两个方法，下面说明干嘛用的

通过前面的使用，清楚了计数器的构造必须指定计数值,这个直接初始化了 AQS内部的state变量

Sync(int count) {
    setState(count);
}

后续的计数-1/判断是否可用都是基于sate进行的

2. countDown() 计数-1的实现

// 计数-1
public void countDown() {
    sync.releaseShared(1);
}


public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) { // 首先尝试释放锁
        doReleaseShared();
        return true;
    }
    return false;
}

protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) {
        int c = getState();
        if (c == 0) //如果计数已经为0，则返回失败
            return false;
        int nextc = c-1;
        // 原子操作实现计数-1
        if (compareAndSetState(c, nextc)) 
            return nextc == 0;
    }
}

// 唤醒被阻塞的线程
private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) { // 队列非空，表示有线程被阻塞
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) { 
            // 头结点如果为SIGNAL,则唤醒头结点下个节点上关联的线程，并出队
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head) // 没有线程被阻塞，直接跳出
            break;
    }
}

上面截出计数减1的完整调用链

尝试释放锁tryReleaseShared，实现计数-1

若计数已经小于0，则直接返回false
否则执行计数(AQS的state)减一
若减完之后，state==0，表示没有线程占用锁，即释放成功，然后就需要唤醒被阻塞的线程了

释放并唤醒阻塞线程 doReleaseShared

如果队列为空，即表示没有线程被阻塞（也就是说没有线程调用了 CountDownLatch#wait()方法），直接退出
头结点如果为SIGNAL, 则依次唤醒头结点下个节点上关联的线程，并出队

疑问一： 看到这个实现，是不是只要countDownLatch的计数为0了，所有被阻塞的线程都会被执行？

改下上面的demo，新增线程4，实现线程2的结果-线程1的结果

public class CountDownLatchDemo {
    
    // ...省略重复
    
    private int sub(int a, int b) {
        return a - b;
    }

    public void calculate() {
        countDownLatch = new CountDownLatch(2);

        Thread thread1 = // ... ;
        Thread thread2 = // ...;
        
        Thread thread3 = new Thread(()-> {
            try {
                System.out.println(Thread.currentThread().getName() + " : 开始执行");
                countDownLatch.await();
                System.out.println(Thread.currentThread().getName() + " : 唤醒");
                Thread.sleep(100); // 确保线程4先执行完相减
                int ans = sum(tmpRes1, tmpRes2);
                System.out.println(Thread.currentThread().getName() +
                        " : calculate ans: " + ans);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程3");

        Thread thread4 = new Thread(()-> {
            try {
                System.out.println(Thread.currentThread().getName() + " : 开始执行");
                countDownLatch.await();
                System.out.println(Thread.currentThread().getName() + " : 唤醒");
                int ans = sub(tmpRes2, tmpRes1);
                Thread.sleep(200); // 保证线程3先输出执行结果，以验证线程3和线程4是否并发执行
                System.out.println(Thread.currentThread().getName() +
                        " : calculate ans: " + ans);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程4");
        
        thread3.start();
        thread4.start();
        thread1.start();
        thread2.start();
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatchDemo demo = new CountDownLatchDemo();
        demo.calculate();

        Thread.sleep(1000);
    }
}

输出如下

线程4 : 开始执行
线程3 : 开始执行
线程2 : 开始执行
线程2 : calculate ans: 15050
线程1 : 开始执行
线程1 : calculate ans: 5005
线程3 : 唤醒
线程4 : 唤醒
线程3 : calculate ans: 20055
线程4 : calculate ans: 10045

上面的实现中，线程3中sleep一段时间，确保线程4的计算会优先执行；线程4计算完成之后的sleep时间，以保证线程3计算完成并输出结果，然后线程4才输出结果；结合输出，这个期望是准确的，也就是说，线程3和线程4被唤醒后是并发执行的，没有先后阻塞顺序

即CountDownLatch计数为0之后，所有被阻塞的线程都会被唤醒，且彼此相对独立，不会出现独占锁阻塞的问题

3. await() 阻塞等待计数为0

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
    

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted()) // 若线程中端，直接抛异常
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}


// 计数为0时，表示获取锁成功
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

// 阻塞，并入队
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED); // 入队
    boolean failed = true;
    try {
        for (;;) {
            // 获取前驱节点
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 获取锁成功，设置队列头为node节点
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) // 线程挂起
              && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

阻塞的逻辑相对简单

判断state计数是否为0，不是，则直接放过执行后面的代码
大于0，则表示需要阻塞等待计数为0
当前线程封装Node对象，进入阻塞队列
然后就是循环尝试获取锁，直到成功（即state为0）后出队，继续执行线程后续代码

III. 小结

1. 使用注意

在创建实例时，必须指定初始的计数值，且应大于0
必须有线程中显示的调用了countDown()计数-1方法；必须有线程显示调用了await()方法（没有这个就没有必要使用CountDownLatch了）
由于await()方法会阻塞到计数为0，如果在代码逻辑中某个线程漏掉了计数-1，导致最终计数一直大于0，直接导致死锁了；
鉴于上面一点，更多的推荐 await(long, TimeUnit)来替代直接使用await()方法，至少不会造成阻塞死只能重启的情况
允许多个线程调用await方法，当计数为0后，所有被阻塞的线程都会被唤醒

2. 实现原理

await内部实现流程:

判断state计数是否为0，不是，则直接放过执行后面的代码
大于0，则表示需要阻塞等待计数为0
当前线程封装Node对象，进入阻塞队列
然后就是循环尝试获取锁，直到成功（即state为0）后出队，继续执行线程后续代码

countDown内部实现流程:

尝试释放锁tryReleaseShared，实现计数-1

若计数已经小于0，则直接返回false
否则执行计数(AQS的state)减一
若减完之后，state==0，表示没有线程占用锁，即释放成功，然后就需要唤醒被阻塞的线程了

释放并唤醒阻塞线程 doReleaseShared

如果队列为空，即表示没有线程被阻塞（也就是说没有线程调用了 CountDownLatch#wait()方法），直接退出
头结点如果为SIGNAL, 则依次唤醒头结点下个节点上关联的线程，并出队

posted @ 2019-08-24 09:25 lllunaticer 阅读(462) 评论(0) 编辑收藏举报

刷新页面返回顶部

龙龙爱阿喵！

古之成大事者,不惟有超世之才,亦必有坚忍不拔之志！

CountDownLatch 使用说明及内部原理

CountDownLatch实现原理及使用姿势

I. 使用说明

0. 接口定义

1. Demo演示

2. 应用场景

II. 实现原理

0. AbstractQueuedSynchronizer （简称AQS）

1. 计数器的初始化

2. countDown() 计数-1的实现

3. await() 阻塞等待计数为0

III. 小结

1. 使用注意

2. 实现原理

公告

龙龙爱阿喵！

古之成大事者,不惟有超世之才,亦必有坚忍不拔之志！

CountDownLatch 使用说明 及内部原理

CountDownLatch实现原理及使用姿势

I. 使用说明

0. 接口定义

1. Demo演示

2. 应用场景

II. 实现原理

0. AbstractQueuedSynchronizer （简称AQS）

1. 计数器的初始化

2. countDown() 计数-1的实现

3. await() 阻塞等待计数为0

III. 小结

1. 使用注意

2. 实现原理

公告

CountDownLatch 使用说明及内部原理