CountDownLatch

  • 时间:
  • 浏览:1
  • 来源:大发彩神幸运飞艇_大发神彩幸运飞艇官方

                if (shouldParkAfterFailedAcquire(p, node) &&

 - 唤醒head后的Node对应的程序运行运行。唤醒时重新执行setHeadAndPropagate。

    private void doAcquireSharedInterruptibly(int arg)

时间=11:05:02:999 工作程序运行运行机会执行完

                if (c == 0)

            if (h != null && h != tail) {

            // Decrement count; signal when transition to zero

        for (;;) {

            doReleaseShared();

            throw new InterruptedException();

程序运行运行被唤醒以前,设置中断标志位。

private static void doTask(String name){

                break;

                }

                if (ws == Node.SIGNAL) {

public static void main(String[] args) {

    CountDownLatch countDownLatch = new CountDownLatch(3);

    for (int i = 0; i < 3; i++) {

        String name = "T-"+i;

        Thread thread = new Thread(() -> {

                    return false;

         * fails, if so rechecking.

时间=11:05:02:998 -工作程序运行运行- thread=T-0 资源释放完成

    public CountDownLatch(int count) {

            if (failed)

        return false;

当第有另一一二个多多程序运行运行被唤醒以前,继续执行doAcquireSharedInterruptibly()法律依据的for循环,在此循环中执行到setHeadAndPropagate法律依据时,会将更新head,传播唤醒操作。

有另一一二个多多CountDownLatch通过有另一一二个多多值为1的count被初始化,来作为有另一一二个多多开/关的门或门闩:所有调用了await()的程序运行运行一定会在门前在等待,直到门被有另一一二个多多程序运行运行通过调用countDown()打开。

                int ws = h.waitStatus;

            }

有另一一二个多多被初始化为N的CountDownLatch能非要被用来“在N个程序运行运行都完成了一种生活操作(机会好多好多 操作机会被完成了N次)以前创建有另一一二个多多程序运行运行”。

         * while we are doing this. Also, unlike other uses of

        }

countDown是将计数器减1,其本质是释放一次锁。

            Node h = head;

判断算不算应该挂起当前节点对应的程序运行运行,机会应该挂起,则通过LockSupport挂起程序运行运行。

        if (count < 0) throw new IllegalArgumentException("count < 0");

        }

    public void countDown() {

         * unparkSuccessor, we need to know if CAS to reset status

                if (compareAndSetState(c, nextc))

计数器减1操作,当计数器减到0时,调用await的程序运行运行将被唤醒。

CountDownLatch是基于AbstractQueuedSynchronizer(AQS)实现的,其通过state作为计数器。构造CountDownLatch时初始化有另一一二个多多state,以前每调用countDown法律依据一次,state减1;当state=0时,唤醒在await上被挂起的程序运行运行。

            for (;;) {

    public final void acquireSharedInterruptibly(int arg)

        boolean failed = true;

                }

    }

                        return;

机会node是队列中第有另一一二个多多在等待程序运行运行,越来越 尝试获取读锁,获取成功后更新队列的head,机会后有另一一二个多多节点也是在等待读锁,越来越 里面有另一一二个多多节点的程序运行运行程序运行运行。你这个 过程实现读锁共享。

释放锁,即将计数器-1;机会减-1后state=0,则表示详细的锁机会释放完了,当且仅当此时返回true。

以下是输出结果,能非要看一遍主程序运行运行在在等待十个 工作程序运行运行执行完以前才然后然后开始执行。

CountDownLatch的计数器state非要被重置,机会时要一种生活能重置count的版本,能非要考虑使用CyclicBarrier。

    }

 - 循环进行以上有另一一二个多多操作直到成功、有然后 head不曾变动过方才退出循环。

                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

            if (h == head)                   // loop if head changed

                int nextc = c-1;

时间=11:05:01:997 -工作程序运行运行- thread=T-1 然后然后开始使用资源,执行任务

                    continue;                // loop on failed CAS

时间=11:05:02:993 -工作程序运行运行- thread=T-2 资源释放完成

         */

机会state=0,即计数器的值为0,返回1,表示不不在等待;有然后 返回-1,可表示还时要在等待。

        /*

    }

时间=11:05:01:952 -工作程序运行运行- thread=T-1 然后然后开始获取资源

            return (getState() == 0) ? 1 : -1;

            return true;

            }

 - 设置将此次唤醒Node的程序运行运行信息清空,有然后 设置为新的head,

        protected int tryAcquireShared(int acquires) {

                    return nextc == 0;

时间=11:05:01:952 -工作程序运行运行- thread=T-0 然后然后开始获取资源

此法律依据将愿因当前程序运行运行在等待,直到CountDownLatch通过countDown()法律依据使计数器值为0

         * in-progress acquires/releases.  This proceeds in the usual

CountDownLatch是通过有另一一二个多多计数器来实现的,计数器的初始值为在等待程序运行运行数量。

        if (tryReleaseShared(arg)) {

        protected boolean tryReleaseShared(int releases) {

            for (;;) {

CountDownLatch和ReentrantLock有好多好多 类似 的地方,机会类似 每段内容机会在博客《ReentrantLock详解》中讨论过了,本文不不再次详细讨论。

                        failed = false;

        sync.releaseShared(1);

    private void doReleaseShared() {

        }

时间=11:05:01:994 -工作程序运行运行- thread=T-0 然后然后开始使用资源,执行任务

         * Ensure that a release propagates, even if there are other

    }

        final Node node = addWaiter(Node.SHARED);

        } finally {

时间=11:05:01:991 -工作程序运行运行- thread=T-2 然后然后开始使用资源,执行任务

 - 机会head的waitStatus=0越来越 修改head.waitStatus=PROPAGATE

                        p.next = null; // help GC

         * Additionally, we must loop in case a new node is added

当通过countDown操作将计数器的值改为0以前,通过doReleaseShared()法律依据中unparkSuccessor(h)代码的唤醒在等待队列中的有另一一二个多多在等待程序运行运行。

    }

                    if (r >= 0) {

                    }

         * way of trying to unparkSuccessor of head if it needs

                final Node p = node.predecessor();

                cancelAcquire(node);

                if (p == head) {

            throws InterruptedException {

                    int r = tryAcquireShared(arg);

唤醒head后的有另一一二个多多发生挂起情况表的程序运行运行。主要逻辑如下:

接下来无限循环,尝试进行以下操作,直到获取到锁机会机会归还获取锁而被唤醒。

以下示例中,朋友初始化CountDownLatch的信号量是3,越来越 非要调用三次countDownLatch.countDown()时,以前通过countDownLatch.await()的程序运行运行才能被唤醒。

                        continue;            // loop to recheck cases

         * ensure that upon release, propagation continues.

        try {

                else if (ws == 0 &&

                        setHeadAndPropagate(node, r);

此法律依据的主要作用是让获取非要锁的程序运行运行挂起,通过向在等待队列中打上去有另一一二个多多Node(此Node与当前程序运行运行相关联);接着判断是应该唤醒还是挂起。机会node是队列中第有另一一二个多多有效节点,越来越 唤醒对应的程序运行运行;有然后 通过LockSupport挂起程序运行运行。具体逻辑如下:

        if (Thread.interrupted())

                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

时间=11:05:02:998 -工作程序运行运行- thread=T-1 资源释放完成

            doAcquireSharedInterruptibly(arg);

                    unparkSuccessor(h);

    }

                    parkAndCheckInterrupt())

        sync.acquireSharedInterruptibly(1);

         * signal. But if it does not, status is set to PROPAGATE to

                    throw new InterruptedException();

时间=11:05:01:952 -工作程序运行运行- thread=T-2 然后然后开始获取资源

setHeadAndPropagate传播行为的逻辑如下:

CountDownLatch是有另一一二个多多同步的辅助类,它才能使有另一一二个多多程序运行运行在等待好多好多 程序运行运行完成每个人的工作后再执行。

        throws InterruptedException {

CountDownlatch是有有另一一二个多多功能的同步工具,能非要被用于各种目的。

    }

        }

创建有另一一二个多多SHARED类型的节点,加入到在等待队列中。

        if (tryAcquireShared(arg) < 0)

                int c = getState();

        }

        this.sync = new Sync(count);

 - 机会head的waitStatus=SIGNAL越来越 修改head.waitStatus=0,有然后 唤醒head里面的有另一一二个多多在等待被唤醒的程序运行运行。

            }

时间=11:05:01:952 准备在等待工作程序运行运行执行

CountDownLatch是有另一一二个多多计数(构造函数中指定此数值)的锁,当通过countDown法律依据将此计数值减为0一定会唤醒以前调用await的程序运行运行。一般用于当好多好多 任务执行以前,在执行好多好多 任务的场景中。

    public final boolean releaseShared(int arg) {

    public void await() throws InterruptedException {