AQS源码解析(上)

最新推荐文章于 2024-07-12 15:51:39 发布

Dream梦犹在

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量212

点赞数 1

文章标签：队列多线程 java

本文链接：https://blog.csdn.net/Dream12306/article/details/105686970

版权

CLH队列：三个人发明的，三个人各取一个字母命名。

AQS（AbstractQueuedSynchronizer）里面有基本的模板方法，包括操作同步队列和条件队列等。

CAS，自旋，LockSupport

继承AQS子类可以自己选择实现的方法有：

tryAcquire 获取独占锁的逻辑
tryRelease 释放独占锁的逻辑
tryAcquireShared 获取共享锁的逻辑
tryReleaseShared 释放共享锁的逻辑
isHeldExclusively 判断是否被独占

源码解析中术语说明

head 队列的头节点，也就是那个thread等于null的节点
first node 队列头head的next node，也就是同步队列中等待获取资源的第一个线程对应的node.

//获取独占锁
public final void acquire(int arg) {
        if (!tryAcquire(arg) && //尝试获取独占锁,其逻辑取决于子类的具体实现
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //进行同步队列排队
            selfInterrupt(); //自中断
    }

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode); //把当前线程封装为Node
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) { //如果tail不为空,尝试把当前节点加入队列最后
            node.prev = pred; //这一步很重要,很牛逼,先把当前节点的pre指向原tail,
            		//必须放到cas操作前面,为后续的唤醒操作从后往前遍历做好准,保证pre!=null
            if (compareAndSetTail(pred, node)) {
                pred.next = node;//如果cas成功then把原tail的next指向当前节点
                return node;
            }
        }
        enq(node);//如果尾节点为空的话进入enq逻辑
        return node;
    }

private Node enq(final Node node) {
        for (;;) {
            Node t = tail; //获取tail对应的引用
            if (t == null) { //如果tail对应的引用为空的话,整个队列就很可能还没初始化
            				 //那么尝试用cas操作head,如果替换head成功,说明初始化成功
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {//如果失败，进入下次循环,直接在尾部追加节点,逻辑和addWaiter的前半段一致.
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

//进入同步队后的逻辑，比如检测和休眠操作
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {//当pre==head时再次尝试tryAcquire
                    setHead(node);//把head=node,node.thead=null,so获取到锁的线程肯定不在队列中
                    p.next = null;// help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) && //检测pre的状态以及相关操作
                    parkAndCheckInterrupt()) //if pre==SIGNAL,then park
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
          	//node的原始状态==0,如果被它的next节点被改为-1,那么它将有负责叫醒next node的责任
            return true;
        if (ws > 0) {
            do {//过滤掉已经是cancelled状态的,
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;//直至找到一个有效状态的,此时才把pred.next = node,
            //所以这中间有很大的时间差,这也就是为什么后续为了找到一个可唤醒的节点采用倒序的原因
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE. 
             * 这个地方之所以不直接返回true进而park的原因初看不明白
             * 为什么要准备park,而不是直接park,结合release逻辑就比较清楚了。
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//UNSAFE.park(false, 0L);
        return Thread.interrupted();//获取是否interrupted并且把此标识清空
    }

//释放锁操作
public final boolean release(int arg) {
        if (tryRelease(arg)) { //尝试释放独占锁,其逻辑取决于子类的具体实现
            Node h = head;
            if (h != null && h.waitStatus != 0) 
            	//此处初读源码的时候觉得很差异
            	//if status==0 now and set to -1 soon at shouldParkAfterFailedAcquire,
            	//then the first node will park permanent;
            	//it's very advisable to execute next itorator rather than park right now.
                unparkSuccessor(h); //如果head.next已经或将要休眠then唤醒它
            return true;
        }
        return false;
    }

private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next;
        //如果first node已经取消
        if (s == null || s.waitStatus > 0) {
            s = null;
            //倒序找到队列最前面的状态合法的节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)//唤醒指定的线程
            LockSupport.unpark(s.thread);
    }

//获取共享锁
public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)//尝试获取共享锁,具体逻辑视子类而定
            doAcquireShared(arg);//获取共享锁失败，进入同步队列
    }

//进入同步队列的逻辑和独占锁的逻辑大致相同，唯有的不同就是：
//在获取到共享锁的时候，会传递唤醒其后面的所有共享节点直至遇到一个独占节点；
//当前上面的说法是在资源充裕的情况下
//至于能唤醒后面几个节点还取决于剩余的资源量，即下面代码的r变量的值
private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);//这里和独占锁不同，独占锁是EXCLUSIVE
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);//最大的不同就在此处，具体分析见下面
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

//设置head,最重要的是传递共享状态到后续节点
private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);
        /*
         * 正常情况下,只要propagate>0就可以了,为什么还要ws<0呢?
         * 因为此刻传递进来的propagate很可能已经不准了
         * 或许传递进来时propagate=0,此时真实值已经>0了
         * 由于一些释放资源的线程没能成功唤醒其他线程,
         * 虽然没能唤起其他线程，但是它留置了PROPAGATE这个状态
         * 让其他线程可以尽可能的去唤醒头节点以消耗资源。
         * 所以这里用了ws<0也可以进入doReleaseShared
         * 据说ws<0以及PROPAGATE是后期加上去的,初版是没这个的。
         */
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

//释放共享锁
public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {//尝试释放共享锁
            doReleaseShared();//唤醒同步队列中的
            return true;
        }
        return false;
    }

private void doReleaseShared() {
        /*
         * 刨除下面的这段逻辑,即假设一个head从未经历下面的逻辑。
         * 个人理解一开始head.status仅可能两种状态0或者-1,不对欢迎留言探讨
         * 如果0,那么这个同步队列很可能创建不久,first node还未把它的head设置为-1进而休眠
         * 如果1,那么这个同步队列可能有很多节点,first node已经将head设置为-1,可能已经休眠也可能没
         * 那么从以上两点来分析下面代码。
         */
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {//我们称这个操作为“-10”
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue; 
                     //cas失败说明有其他的线程可能在执行doReleaseShared这个操作
                     //一般情况下,status会从-1变为0，然后去唤醒一个线程
                    unparkSuccessor(h);
                }
                else if (ws == 0 && //我们称这个操作为“0-3”
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            //1.本次循环结束的时候head还没用发生变化,为了保证setHead的有序性,所以退出循环。
            //2.head没发生变化,说明没用符合条件的需要唤醒的节点
            if (h == head) 
                break;
        }
    }

首先明白一点，同一时间可能有多个线程都在执行doReleaseShared，也就是都在尝试去唤醒first node，但是唤醒之前需要更改head status，由于这一步是CAS操作，所以只会有一个线程成功并unpark，并且这个被唤醒的线程，在经过一些逻辑判断后，会进一步传递这个Share的状态。
更改head的操作，肯定是一个已经获取到资源的线程，并且setHead操作是一个普通的非cas操作，所以同时就有可能很多线程都在setHead，那么怎么保证setHead是按顺序的呢，也就是按顺序唤醒？
我们知道doReleaseShared里面有个循环操作，当一次循环结束的时候，会检测head是否发生变化，如果发生了变化，说明setHead已经完毕，线程唤醒并且获得资源完毕，可以进行下次的循环继续唤醒，否则的话，直接退出循环。

上面的doReleaseShared的逻辑可能的执行情况如下：

head status -1

线程A执行-10失败，直接进入下次循环，有可能其他线程也在执行doReleaseShared.
线程A执行-10成功，唤醒线程B，head status改为0
- 线程B或者其他线程已经把head改掉，进入下次循环，尝试去唤醒下一个头节点的next node
- 线程B或者其他线程还没把head改掉，那么退出本次循环
- 另外一个获得资源的线程恰巧进入doReleaseShared逻辑，那么它获得head status就是0，然后它将会执行0-3逻辑，也就是下面的逻辑。

head status 0

线程A执行0-3失败，直接进入下次循环，有可能其他线程也在执行doReleaseShared.
线程A执行0-3成功，head status改为-3
- 线程B或者其他线程已经把head改掉，进入下次循环，尝试去唤醒下一个头节点的next node
- 线程B或者其他线程还没把head改掉，那么退出本次循环，那么这种情况下，本来该唤醒一个线程的，现在却没唤醒，直接退出了，那是不是就得在检测是否需要继续唤醒的时候做个宽松校验呢，看setHeadAndPropagate，在这里面做了在h.waitStatus < 0这种情况下的继续唤醒，这也解释了为什么不仅仅判断propagate>0的原因。
- 另外一个获得资源的线程恰巧能进入doReleaseShared逻辑，那么它获得head status就是-3，虽然setHeadAndPropagate中的propagate等于0。

个人理解：
在短时间内会有大量的线程被唤醒，但是这些被唤醒的线程不一定都能获得资源，如果获取不到资源的话会继续park；所谓的传播PROPAGATE，不是一个线程把状态转播到同步队列的其他节点，而是在不同线程间的传播，一个线程没干完的事儿，另外一个线程继续干，继续发扬光大，即传播。