面试必考AQS-排它锁的申请与释放

引子

前文《面试必考AQS-排它锁的申请与释放》已经对AQS中对于排它锁的申请与释放流程进行了总结。而对于申请与释放,在AQS中提现的是与锁并无关系,而是针对同步队列的操作,向同步队列中添加、移除Node实例对象,操作Node中的线程对象。而我们日常使用的锁类,只是表象,何时可以加锁、解锁,达到何种条件才算加锁成功、解锁成功,这才是AQS锁实现的功能。接下来将从源码层面看一下,排它锁的申请与释放在AQS中具体是怎样实现的。

排它锁的申请

再看一次申请流程的大致方法调用:

public final void acquire(int arg){...} // 获取排它锁的入口
# protected boolean tryAcquire(int arg); // 尝试直接获取锁
final boolean acquireQueued(final Node node, int arg) {...} // AQS中获取排它锁流程整合
private Node addWaiter(Node mode){...} // 将node加入到同步队列的尾部
# protected boolean tryAcquire(int arg); // 如果当前node的前置节点pre变为了head节点,则尝试获取锁(因为head可能正在释放)
private void setHead(Node node) {...} // 设置 同步队列的head节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {...} // 如果获取锁失败,则整理队中节点状态,并判断是否要将线程挂起
private final boolean parkAndCheckInterrupt() {...} // 将线程挂起,并在挂起被唤醒后检查是否要中断线程(返回是否中断)
private void cancelAcquire(Node node) {...} // 取消当前节点获取排它锁,将其从同步队列中移除
static void selfInterrupt() {...} // 操作将当前线程中断

先看一下入口方法acquire(int arg)的代码。

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

源码上是先调用tryAcquire()方法,如果返回false,则进入acquireQueued();由于tryAcquire()是由子类实现的,我们暂时先不看,留到以后梳理AQS实现类时再串讲。

那么从tryAcquire()从方法名来讲就是“尝试获取锁”,先假设return=false,也就是“尝试获取锁失败”,继续执行调用acquireQueued()。

在进入acquireQueued()之前,会先调用一次addWaiter(),传入了一个Node.EXCLUSIVE对象;Node.EXCLUSIVE在前文有介绍,是Node类中一个实例变量成员,用于标记排他类型的Node实例。

那么看一下addWaiter()方法,直接看一下方法内注释吧。

    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode); // 用入参mode=Node.EXCLUSIVE,创建了一个Node实例。
        // 将新创建的节点 加入 同步队列的尾部
        Node pred = tail; // 拿到同步队列尾指针
        if (pred != null) {
            node.prev = pred; // 追加到尾部
            if (compareAndSetTail(pred, node)) { // cas方式,更新尾指针指向 新节点node
                pred.next = node; 
                return node;
            }
        }
		// 如果上述方式加入队列失败,进入enq(node)方法。
        enq(node);
        return node;
    }
	
    private Node enq(final Node node) {
        for (;;) { // 无限尝试
            Node t = tail;
            if (t == null) { 
				// 尾结点不能指向为null,说明队列为null,需要初始化同步队列的头尾指针
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
				// 这段代码的含义,与addWaiter()中的一致,也就是不停尝试将节点加入到同步队列
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

那么addWaiter()方法就一个目的:将新的node加入到同步队列的尾部,并将node返回。

接下来继续调用acquireQueued()方法,我们看看它做了什么:

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;// 一个状态标记,goto t1
        try {
            boolean interrupted = false; // 一个状态标记,goto t2
            for (;;) {
                final Node p = node.predecessor(); // 获取node的前置节点p,前文有介绍过
                if (p == head && tryAcquire(arg)) {  // 如果p是头节点,立即尝试获取锁(注意只有队列head的下一个节点才能去获取锁)
                    setHead(node); // 如果返回true,说明获取锁成功,设置head为当前节点(说明原有head已经释放锁)
                    p.next = null; // help GC
                    failed = false; 
                    return interrupted; // t2',将中断标识返回
                }
                if (shouldParkAfterFailedAcquire(p, node) &&  
                    parkAndCheckInterrupt())
                    interrupted = true; // t2,是否中断线程的标记,goto t2'
            }
        } finally {
            if (failed) // t1,状态标识的值,决定是否调用cancelAcquire()
                cancelAcquire(node);
        }
    }

流程比较清晰,一个for(;;),循环尝试获取锁,如果节点到达同步队列的head之后,则尝试申请锁,申请成功返回,否则调用shouldParkAfterFailedAcquire()和parkAndCheckInterrupt(),我们继续往下看。

    // 入参:pred 就是当前节点的前置节点,node就是当前节点
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus; // 获取前置节点的状态
        if (ws == Node.SIGNAL) // SIGNAL 代表 节点等待被唤醒,可以理解为是一种阻塞状态的标记
            /*
             * pred节点为SIGNAL状态,可以认为node允许阻塞
             */
            return true;
        if (ws > 0) { 
	    // 由于ws的状态只有CANCEL是大于0,因此节点无效,前置节点可以从队列移除            
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0); // 遍历同步队列中,node前面的所有节点,将CANCEL状态的都移除
            pred.next = node;
        } else {
            // 如果前置节点状态 小于0,说明是正常节点(但不是SIGNAL),
            // 先cas设置为SIGNAL(标记存在后置节点),然后交给外层for(;;)再次尝试申请锁
	    // else中不返回true的目的是:
            //    防止过早进入parkAndCheckInterrupt(),而应该再次尝试申请锁(临近状态控制)
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

如果shouldParkAfterFailedAcquire()返回true,则进入parkAndCheckInterrupt()方法,这里只做了一件事,将线程挂起。

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this); // 挂起当前线程;由此线程等待被唤醒
	// other thread going to work..
        return Thread.interrupted(); // 当线程被唤醒后,返回线程是否中断
    }

我们再回到acquireQueued()方法看一下,注意看注释:

    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)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
		// 这里的工作是:检查前置节点状态,如果是SIGNAL,则让当前node代表的线程挂起
		// 如果不是SIGNAL,则会继续for(;;)努力申请锁。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) 
		    // 如果parkAndCheckInterrupt()==true说明线程被中断,需要设置interrupted标记
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

再看看cancelAcquire()内部实现:

    private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if (node == null)
            return;
		
	// 节点操作取消申请,清空线程对象
        node.thread = null;

        // 将同步队列中node前的节点,移出队列
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // preNext 是清理后的同步队列的pre节点的下一个有效节点
        Node predNext = pred.next;

        // Can use unconditional write instead of CAS here.
        // After this atomic step, other Nodes can skip past us.
        // Before, we are free of interference from other threads.
        node.waitStatus = Node.CANCELLED;

        // 如果node在队尾,则将队尾tail指向pred节点
        if (node == tail && compareAndSetTail(node, pred)) {
            compareAndSetNext(pred, predNext, null);// 并将pred节点的next指向predNext。
	    // 以上都是在整理同步队列节点;node在队尾,直接丢弃即可
        } else {
            // If successor needs signal, try to set pred's next-link
            // so it will get one. Otherwise wake it up to propagate.
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
		// t3 能进入这里的条件是:
		// 1、前置节点不是head节点
		// 并且
		// 2、前置节点状态是SIGNAL 或者 (前置节点状态小于0 并且 可以修改为SIGNAL)
		// 并且
		// 3、前置节点的线程不为null
		// 以上,都是在判定 pred节点是否为一个有效节点
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
		    // 将前置节点的next指向当前node的next,从同步队列中移除node
            } else {
		// 如果t3 的条件未达到,
		// 则手动唤醒node代表的线程
                //     (假设node还在被挂起,则可以交给acquireQueued()中的for(;;) 重新搞一波)
                unparkSuccessor(node); 
            }
            node.next = node; // help GC
        }
    }

以上,就是申请排它锁的全部流程,其中比较关键的方法,都是涉及到waitStatus的值变化的方法,如shouldParkAfterFailedAcquire()、parkAndCheckInterrupt()、cancelAcquire(),思路要理清才能搞明白。

重新回忆下申请锁都做了什么:

1、先交给子类去尝试申请锁,如果申请成功了,则结束流程;
2、否则将申请线程包装为node节点,并加入同步队列
3、循环检查当前节点的前置节点是否为head,如果是则申请获取锁
4、否则检查节点状态,并将线程挂起,等待前面有节点释放锁后,来主动唤醒该线程
5、将CANCEL状态的节点清理掉。

锁既然已经申请到了,那么不可避免的就要释放;接下来再分析一下释放锁的源码。

排它锁的释放

再看一次释放流程的大致方法调用:

public final boolean release(int arg) {...} // 释放排它锁的入口
# protected boolean tryRelease(int arg); // 尝试直接释放锁
private void unparkSuccessor(Node node) {...} // 唤醒后继节点

先看入口方法release()的工作:

    public final boolean release(int arg) {
        if (tryRelease(arg)) { // 同样先让子类执行tryRelease()来尝试释放锁,
	    // 这回是如果成功了继续
            Node h = head;
            if (h != null && h.waitStatus != 0)
		// head如果不为null并且状态不是0,则调用unparkSuccessor()
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

释放锁具体怎么释放,交给了子类去操作,那么说明一点,tryRelease()中并不涉及同步队列的操作。而unparkSuccessor(h);中做的事情,才是AQS的关键。

	private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
	    // 修改node节点状态为SIGNAL

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) { // head的下一个节点,如果为CANCEL状态
            s = null;
            // 清理同步队列,注意这里是从尾部开始向前清理的
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
	// 由于是从尾部清理,因此s最后的值应该是同步队列中第一个waitState<=0的节点
	// 那么unpark()操作的就是同步队列中第一个等待被唤醒的节点
        if (s != null)
            LockSupport.unpark(s.thread);
    }

以上就是释放锁的流程;重新回忆一下释放锁到底干了什么。

1、先交给子类去尝试释放锁,如果成功则处理同步队列的节点
2、将同步队列中的无效节点移除,然后将队列中node之后第一个有效节点唤醒

其实就这么简单,但是代码很精妙,尤其是从尾部遍历同步队列的思路。

尾声

对于AQS中排它锁的申请与释放,思路是比较清晰的,而且行为方向单一,就是针对同步队列的入队与出队操作,以及在某些情况下针对同步队列进行遍历;再加上LockSupport的park和unpark调用,来控制线程状态。

这就是AQS的一部分,仔细分析源码,其实没那么复杂。

发布了44 篇原创文章 · 获赞 8 · 访问量 1万+
App 阅读领勋章
微信扫码 下载APP
阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览