美文网首页
CountDownLauth深入分析

CountDownLauth深入分析

作者: 天外流星for | 来源:发表于2018-06-10 12:40 被阅读0次

    AQS介绍

    在AQS维护的CLH队列锁中,每个节点(Node)代表着一个需要获取锁的线程。该Node中有两个常量SHARE、EXCLUSIVE。其中SHARE代表着共享模式,EXCLUSIVE代表着独占模式。

    其中共享模式是允许多个线程可以获取同一个锁,而独占模式则一个锁只能被一个线程持有,其他线程必须要等待。

    AQS结构:

    // 头结点,虚拟节点,并不在阻塞队列中

    private transient volatile Node head;

    // 阻塞的尾节点,每个新的节点进来,都插入到最后,也就形成了一个隐视的链表

    private transient volatile Node tail;

    // 这个状态表示的count数量,只是为了AQS统一,这里叫做state

    private volatile int state;

    // 代表当前持有独占锁的线程

    private transient ThreadexclusiveOwnerThread; //继承自AbstractOwnableSynchronizer

    预热题:CountDownLatch 和 CyclicBarrier 有什么区别?

    CountDownLatch的构造函数(采用的是一种公平锁机制)

    同步队列的基本结构

    CountDownLatch源码分析

    构造方法,需要传入一个不小于 0 的整数:

    public CountDownLatch(int count) {

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

        this.sync = new Sync(count);

    }// 内部封装一个 Sync 类继承自 AQS private static final class Sync extends AbstractQueuedSynchronizer {

        Sync(int count) {

            // 这样就 state == count 了        setState(count);

        }

        ...

    }

    思路分析:AQS 里面的 state 是一个整数值,这边用一个 int count 参数其实初始化就是设置了这个值,所有调用了 await 方法的等待线程会挂起,然后有其他一些线程会做 state = state - 1 操作,当 state 减到 0 的同时,那个线程会负责唤醒调用了 await 方法的所有线程。

    对于 CountDownLatch,我们仅仅需要关心两个方法,一个是 countDown() 方法,另一个是 await() 方法。countDown() 方法每次调用都会将 state 减 1,直到 state 的值为 0;而 await 是一个阻塞方法,当 state 减为 0 的时候,await 方法才会返回。await 可以被多个线程调用,小结:所有调用了 await 方法的线程阻塞在 AQS 的阻塞队列中,等待条件满足(state == 0),将线程从队列中一个个唤醒过来。

    我们用以下程序来分析源码,t1 和 t2 负责调用 countDown() 方法,t3 和 t4 调用 await 方法阻塞:

    public class CountDownLatchDemo {

        public static void main(String[] args) {

            CountDownLatch latch = new CountDownLatch(2);

            Thread t1 = new Thread(new Runnable() {

                @Override           

               public void run() {

                    try {

                        Thread.sleep(5000);

                    } catch (InterruptedException ignore) {

                    }

                    // 休息 5 秒后(模拟线程工作了 5 秒),调用 countDown()               

                     latch.countDown();

                }

            }, "t1");

            Thread t2 = new Thread(new Runnable() {

                @Override           

                public void run() {

                    try {

                        Thread.sleep(10000);

                    } catch (InterruptedException ignore) {

                    }

                    // 休息 10 秒后(模拟线程工作了 10 秒),调用 countDown()                latch.countDown();

                }

            }, "t2");

            t1.start();

            t2.start();

            Thread t3 = new Thread(new Runnable() {

                @Override           

                public void run() {

                    try {

                        // 阻塞,等待 state 减为 0                   

                         latch.await();

                        System.out.println("线程 t3 从 await 中返回了");

                    } catch (InterruptedException e) {

                        System.out.println("线程 t3 await 被中断");

                        Thread.currentThread().interrupt();

                    }

                }

            }, "t3");

            Thread t4 = new Thread(new Runnable() {

                @Override           

                public void run() {

                    try {

                        // 阻塞,等待 state 减为 0                   

                           latch.await();

                        System.out.println("线程 t4 从 await 中返回了");

                    } catch (InterruptedException e) {

                        System.out.println("线程 t4 await 被中断");

                        Thread.currentThread().interrupt();

                    }

                }

            }, "t4");

            t3.start();

            t4.start();

        }

    }

    上述程序,大概在过了 10 秒左右的时候,会输出:

    线程 t3 从 await 中返回了

    线程 t4 从 await 中返回了// 这两条输出,顺序不是绝对的// 后面的分析,我们假设 t3 先进入阻塞队列

    首先,我们来看 await() 方法,它代表线程阻塞,等待 state 的值减为 0。

    public void await() throws InterruptedException {

        sync.acquireSharedInterruptibly(1);

    }

    public final void acquireSharedInterruptibly(int arg)    throws InterruptedException {

            if (Thread.interrupted())

            throw new InterruptedException();

            // t3 和 t4 调用 await 的时候,state 都大于 0。    // 也就是说,这个 if 返回 true,然后往里看   

          if (tryAcquireShared(arg) < 0)

            doAcquireSharedInterruptibly(arg);

    }

    // 只有当 state == 0 的时候,这个方法才会返回 1

    protected int tryAcquireShared(int acquires) {

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

    }

    从方法名我们就可以看出,这个方法是获取共享锁,并且此方法是可中断的(中断的时候抛出 InterruptedException 退出这个方法)。

    private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {

        // 1. 入队:共享锁和独占锁共用逻辑    

    final Node node = addWaiter(Node.SHARED);

        boolean failed = true;

        try {

            for (;;) {

                final Node p = node.predecessor();

                if (p == head) {

                    // 同上,只要 state 不等于 0,那么这个方法返回 -1               

                   int r = tryAcquireShared(arg);

                    if (r >= 0) {

                        setHeadAndPropagate(node, r);

                        p.next = null; // help GC                   

                      failed = false;

                        return;

                    }

                }

                // 2   这里是主要逻辑,形成阻塞          

               if (shouldParkAfterFailedAcquire(p, node) &&

                    parkAndCheckInterrupt())

                    throw new InterruptedException();

            }

        } finally {

            if (failed)

                cancelAcquire(node);

        }

    }

    countDown() 方法:

    public void countDown() {

        sync.releaseShared(1);

    }

    public final boolean releaseShared(int arg) {

        // 只有当 state 减为 0 的时候,tryReleaseShared 才返回 true    // 否则只是简单的 state = state - 1 那么 countDown 方法就结束了 

      if (tryReleaseShared(arg)) {

            // 唤醒 await 的线程        doReleaseShared();

            return true;

        }

        return false;

    }// 这个方法很简单,用自旋的方法实现 state 减 1protected boolean tryReleaseShared(int releases) {

        for (;;) {

            int c = getState();

            if (c == 0)

                return false;

            int nextc = c-1;

            if (compareAndSetState(c, nextc))

                return nextc == 0;

        }

    }

    countDown 方法就是每次调用都将 state 值减 1,如果 state 减到 0 了,那么就调用下面的方法进行唤醒阻塞队列中的线程:

    // 调用这个方法的时候,state == 0// 这个方法先不要看所有的代码,按照思路往下到我写注释的地方,其他的之后还会仔细分析private void doReleaseShared() {

        for (;;) {

            Node h = head;

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

                int ws = h.waitStatus;

                // t3 入队的时候,已经将头节点的 waitStatus 设置为 Node.SIGNAL(-1) 了           

               if (ws == Node.SIGNAL) {

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

                        continue;            // loop to recheck cases               

                                                  // 就是这里,唤醒 head 的后继节点,也就是阻塞队列中的第一个节点                  

                       unparkSuccessor(h);

                }

                else if (ws == 0 &&

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

                         continue;                // loop on failed CAS     

      }

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

             break;

        }

    }

    一旦 t3 被唤醒后,我们继续回到 await 的这段代码,parkAndCheckInterrupt 返回,我们先不考虑中断的情况:

    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) {

                        setHeadAndPropagate(node, r); // 2. 这里是下一步                    p.next = null; // help GC                    failed = false;

                        return;

                    }

                }

                if (shouldParkAfterFailedAcquire(p, node) &&

                    // 1. 唤醒后这个方法返回                parkAndCheckInterrupt())

                    throw new InterruptedException();

            }

        } finally {

            if (failed)

                cancelAcquire(node);

        }

    }

    接下来,t3 会进到 setHeadAndPropagate(node, r) 这个方法,先把 head 给占了,然后唤醒队列中其他的线程:

    private void setHeadAndPropagate(Node node, int propagate) {

        Node h = head; // Record old head for check below    setHead(node);

        // 下面说的是,唤醒当前 node 之后的节点,即 t3 已经醒了,马上唤醒 t4    // 类似的,如果 t4 后面还有 t5,那么 t4 醒了以后,马上将 t5 给唤醒了    if (propagate > 0 || h == null || h.waitStatus < 0 ||

            (h = head) == null || h.waitStatus < 0) {

            Node s = node.next;

            if (s == null || s.isShared())

                // 又是这个方法,只是现在的 head 已经不是原来的空节点了,是 t3 的节点了           

            doReleaseShared();

        }

    }

    又回到这个方法了,那么接下来,我们好好分析 doReleaseShared 这个方法,我们根据流程,头节点 head 此时是 t3 节点了:

    // 调用这个方法的时候,

    state == 0private void doReleaseShared() {

        for (;;) {

            Node h = head;

            // 1. h == null: 说明阻塞队列为空        // 2. h == tail: 说明头结点可能是刚刚初始化的头节点,        //  或者是普通线程节点,但是此节点既然是头节点了,那么代表已经被唤醒了,阻塞队列没有其他节点了        // 所以这两种情况不需要进行唤醒后继节点       

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

                int ws = h.waitStatus;

                // t4 将头节点(此时是 t3)的 waitStatus 设置为 Node.SIGNAL(-1) 了            if (ws == Node.SIGNAL) {

                    // 这里 CAS 失败的场景请看下面的解读                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

                        continue;            // loop to recheck cases                // 就是这里,唤醒 head 的后继节点,也就是阻塞队列中的第一个节点            

                      unparkSuccessor(h);

                }

                else if (ws == 0 &&

                        // 这个 CAS 失败的场景是:执行到这里的时候,刚好有一个节点入队,入队会将这个 ws 设置为 -1                    !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

                    continue;                // loop on failed CAS     

      }

            // 如果到这里的时候,前面唤醒的线程已经占领了 head,那么再循环        // 否则,就是 head 没变,那么退出循环,        // 退出循环是不是意味着阻塞队列中的其他节点就不唤醒了?当然不是,唤醒的线程之后还是会调用这个方法的       

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

        break;

        }

    }

    小结:

    我们知道在使用Java内置锁时,可以使用wait、notify方法来阻塞、唤醒线程,但是AQS并没有采用该模式,而是通过LockSupport.park() 和 LockSupport.unpark() 的本地方法来实现线程的阻塞和唤醒。

    相关文章

      网友评论

          本文标题:CountDownLauth深入分析

          本文链接:https://www.haomeiwen.com/subject/yenzrftx.html