AQS CountDownLatch共享锁源码分析原理解读

最新推荐文章于 2024-06-30 20:23:11 发布

skindow

最新推荐文章于 2024-06-30 20:23:11 发布

阅读量187

点赞数

分类专栏： java源码分析文章标签： java 源码 AQS

本文链接：https://blog.csdn.net/qq_42255763/article/details/114685331

版权

java源码分析专栏收录该内容

7 篇文章 0 订阅

订阅专栏

说明

建议先了解ReentrantLock源码，这里有些地方在上期介绍ReentrantLock源码时已经说过了，这里就不过多赘述了，见谅。

作用

CountDownLatch 主要是记录某些线程满足某个条件时，去唤醒主线程（被await的线程）。下面看一个demo

DEMO

package com.skindow.sql;

import java.util.concurrent.CountDownLatch;

/**
 * @ Author     ：syc.
 * @ Date       ：Created in 09:32 2021/3/12
 * @ Description：
 * @ Modified By：
 * @ Version:
 */
public class CountDownTest {

    public static final Integer count = 10;

    public static final CountDownLatch COUNT_DOWN_LATCH = new CountDownLatch(count);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            myThread myThread = new myThread();
            myThread.setName("test_" + i);
            myThread.start();
        }
        try {
            COUNT_DOWN_LATCH.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count + "个线程全部执行完毕");
    }

    private static class myThread extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " RUNNING");
            COUNT_DOWN_LATCH.countDown();
            System.out.println(Thread.currentThread().getName() + " END");
        }
    }
}

打印如下：

test_0 RUNNING
test_2 RUNNING
test_0 END
test_1 RUNNING
test_3 RUNNING
test_3 END
test_2 END
test_4 RUNNING
test_4 END
test_1 END
test_6 RUNNING
test_5 RUNNING
test_6 END
test_5 END
test_7 RUNNING
test_8 RUNNING
test_8 END
test_9 RUNNING
test_7 END
test_9 END
10个线程全部执行完毕

结构图

在这里插入图片描述

构造函数

    public CountDownLatch(int count) {
    	//初始化一个同步队列
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

内部类Sync

	//Sync 继承AbstractQueuedSynchronizer
	//通过上篇ReentrantLock源码分析，我们知道该抽象类是一个同步阻塞队列，先进先出原则
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
		//设置锁状态
        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }
		//没有可用的共享资源返回1否则返回-1
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
		//总结：该方法主要是判断解锁成功与否，如果本身没有被锁则解锁失败,但是如果解锁时发现锁状态大于1这时候也会解锁失败
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            //如果当前锁状态为释放状态则返回false
            //如果锁状态不是释放状态则自旋将锁状态减一，如果自旋失败，则会无限制自旋，直到修改成功，这个时候返回锁释放与否
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

1. CountDownLatch countDown()方法

    public void countDown() {
        sync.releaseShared(1);
    }

2. AbstractQueuedSynchronizer releaseShared(int arg) 方法

    public final boolean releaseShared(int arg) {
    	//这里上面已经说明了，尝试释放锁，锁为释放状态才会返回ture
    	//这里也解释了为啥要new Sync(count)带一个count状态的锁
    	//试想下，当state为10时，第一个线程调用countDown方法，
    	//进来state减去1，state变为9不满足if条件，也就是锁资源不是释放状态，
    	//只有当第十个线程调用countDown方法，才会去调用doReleaseShared方法，去唤醒那个被wait方法等待的线程
        if (tryReleaseShared(arg)) {
        	//走到这里证明没有可用的信号量了已经为0了，这里可以唤醒被等待的线程了
            doReleaseShared();
            return true;
        }
        return false;
    }

3. AbstractQueuedSynchronizer doReleaseShared()方法

   private void doReleaseShared() {
        for (;;) {
            Node h = head;
            //头节点不等于尾节点，说明队列存在两个节点以上
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                //如果头节点状态为SIGNAL状态，则自旋将其状态改为0，如果自旋成功则
                //唤醒头节点下一节点对应的线程
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;
                     //上期ReentrantLock源码有说明         
                    unparkSuccessor(h);
                }
                //如果头节点状态为0，则自旋将其状态改为PROPAGATE状态
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            //为啥有这个h == head判断
            //其一，当头节点为空，或者头节点就是尾结点也就是说队列只有一个队列，则会
            //跳出这个循环不做任何逻辑处理,这里暂时不考虑头节点为空的状况，头节点和尾结点相同，证明是一个单节点而且必然是一个没有线程的节点
            //因为在初始化队列时，头节点就是一个僵尸节点
            //其二，就是说走了上面的自旋逻辑，并且自旋成功了，
            //但是发现这个时候的旧头节点，和当前的新头节点不一样，这时候会重新走一遍唤醒满足条件的节点线程
            //那么h是绝对不会变的，变得只有head，而且只有这其中只有unparkSuccessor方法会去改变head
            //因为unparkSuccessor会去唤醒等待的线程，一旦线程唤醒成功，则会去重新分配头节点
            //这个时候就会出现新的头节点和旧的头节点不匹配
            //但是这个时候不会break，会再次去判断并唤醒其他线程去争夺共享锁
            if (h == head)                   // loop if head changed
                break;
        }
    }

总结：

判断头节点状态，如果头节点状态为SIGNAL等待状态（在ReentrantLock里代表初始化等待状态），则将其状态改为0，并唤醒后节点的线程。
如果头节点状态为0则将其状态改为PROPAGATE状态

注意 for ( ; ; ) 这里是个死循环，如果自旋失败，则会无限制自旋下去

4. CountDownLatch await() 方法

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

5. AbstractQueuedSynchronizer acquireSharedInterruptibly(int arg)方法

    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
            //如果当前线程中断则抛出中断异常，并清除中断标志
        if (Thread.interrupted())
            throw new InterruptedException();
            //0 ？ 1 ：-1 tryAcquireShared(arg) 大于0 则表示 没有可用的信号量（共享锁）
            //小于0 表示含有可用的信号量
            //也就是如果小于0成立，说明原先初始化的共享锁没有完全分完，
            //这个时候就要调用doAcquireSharedInterruptibly方法，将当前线程挂起，等待共享锁分完然后被唤醒
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

6.AbstractQueuedSynchronizer doAcquireSharedInterruptibly(int arg)方法

    /**
     * Acquires in shared interruptible mode.
     * @param arg the acquire argument
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        //向队列末尾添加一个共享节点
        //第一次进来时执行addaddWaiter方法后，头节点是一个空线程的节点，尾节点就是当前线程节点
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
            	//判断当前节点前节点是否为头节点
                final Node p = node.predecessor();
                if (p == head) {
                	//如果r >= 0 证明信号量被全部countDown掉了，此时可以
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                    	//走到这里，说明该节点为第二节点，且信号量为0了
                    	//r 等于1
                    	//设置将当前节点设置为头节点并解绑线程和前节点的关系
                    	//某些条件成立下还回去唤醒后面线程
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                //修改前节点状态为SIGNAL状态，有必要的话会清除前面一些被取消的及节点
                //前节点修改为SIGNAL状态后，当前节点就会被挂起直至被前节点唤醒
                //注意这里被唤醒后如果发现有中断标志会抛出中断异常
                //唤醒后就会重新走一遍是不是当前节点前节点是不是头节点，从而重新设置头节点
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
        	//走到这里，意思线程唤醒后发现被中断了，这时会抛出中断异常，且此时该节点因为在队列当中，所以需要将该节点改为取消状态，并重新调整队列或者唤醒后面等待节点对应的线程（细节的话请看上篇ReentrantLock源码分析）
            if (failed)
                cancelAcquire(node);
        }
    }

7. AbstractQueuedSynchronizer setHeadAndPropagate(Node node, int propagate) 方法

    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        //将当前Node节点设置为头节点 这里也会将关联的线程和前节点解绑
        setHead(node);
        //前面tryAcquireShared(arg)>=0 那么propagate必然等于1 所以if条件是成立的
        // h为旧的头节点，当前的node为head节点并且此时它的前节点和线程被解绑了
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            //由CountDownLatch创建的节点都是共享节点，所以这里必然成立
            if (s == null || s.isShared())
            	//从队列中唤醒等待的线程
                doReleaseShared();
        }
    }

总结

countDown 和 wait 方法没有强制性的先后关系，就是谁先执行的情况这是不可控制的

countDown 步骤

获取共享锁并共享锁状态减一
一旦共享锁获取完毕之后（状态为0了），就从阻塞队列中唤醒满足条件的线程

await 步骤

判断当前共享锁状态，如果共享锁没有分配完，才会往后面走（为啥这么判断？是因为如果共享锁在执行await方法前就已经分配完了，完全不用走后面流程挂起当前线程了）
如果线程被中断，则抛出中断异常
向阻塞队列末尾添加一个当前线程的节点
当前节点前节点是头节点，则将当前节点设置为头节点，并从阻塞队列中唤醒满足条件的线程
当前节点前节点不是头节点，此时如果前节点不是signal状态则初始化为该状态，有必要的话，会清理前面取消状态的节点
前节点为signal状态就挂起当前线程等待唤醒
被其他线程唤醒后，重新从第四部来过
最后如果在唤醒后发现中断了，会抛出中断异常，而且将当前节点改为取消状态，并清理队列中该节点的引用，有必要的话会唤醒头节点后面等待的线程

skindow

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AQS CountDownLatch共享锁源码分析原理解读

说明建议先了解ReentrantLock源码，这里有些地方在上期介绍ReentrantLock源码时已经说过了，这里就不过多赘述了，见谅。CountDownLatchCountDownLatch 主要是记录线程满足某个条件时，去唤醒主线程（被await的线程）。下面看一个demoDEMOpackage com.skindow.sql;import java.util.concurrent.CountDownLatch;/** * @ Author ：syc. * @ Date
复制链接

扫一扫