AQS源码探究_04 成员方法解析(释放锁、响应中断出队逻辑)

今天药忘吃喽~ 2022-10-21 03:41 91阅读 0赞

## AQS成员方法解析(释放锁逻辑) ##

### 1. unlock释放锁方法 ###

// 位于RentrantLock中：释放锁的方法
    public void unlock() { 
        // 释放锁
        sync.release(1);
    }
    
    // 位于AQS的静态内部类Sync中：真正释放锁的方法
    // RentrantLock.unlock() -> sync.release()
    public final boolean release(int arg) { 
        // tryRelease尝试释放锁：
        // true: 当前线程已经完全释放锁
        // false：当前线程尚未完全释放锁
        if (tryRelease(arg)) { 
            // head 什么情况下会被创建出来？
            // 当持锁线程未释放线程，且持锁期间有其他线程想要获取锁时，其他线程发现无法获取锁，
            // 且此时阻塞队列是空队列，此时后续线程会为当前持锁线程构建出一个head节点(将持锁线程封装入head)
            // 然后后续线程会追加到head节点的后面(成为head的后驱)
            Node h = head;
            
            // 条件1：h != null成立，说明队列中的head节点已经初始化过了，ReentrantLock在试用期间，发生过多线程竞争了~
            // 条件2：h.waitStatus != 0 成立，说明当前head后面一定插入过node节点~
            if (h != null && h.waitStatus != 0)
                // 唤醒后驱节点~
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

### 2. tryRelease尝试释放锁的方法 ###

// 位于AQS的静态内部类Sync中：尝试释放锁方法
    // true: 当前线程已经完全释放锁 | false：当前线程尚未完全释放锁
    protected final boolean tryRelease(int releases) { 
        // state状态变量的值相减
        int c = getState() - releases;
        // 如果条件成立：说明当前线程并未持锁 -> 直接抛异常
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        
        // 当前线程持有锁
        
        // 当前线程是否已经完全释放锁，默认初始值false
        boolean free = false;
        
        // c == 0条件成立时：说明当前线程已经达到完全释放锁的条件
        if (c == 0) { 
            // free = true 当前线程已经完全释放锁
            free = true;
            // 更新当前持锁线程为null
            setExclusiveOwnerThread(null);
        }
        // 更新state（基于CAS）
        setState(c);
        // 返回free
        return free;
    }

### 3. unparkSuccessor唤醒后驱节点线程的方法 ###

// 位于AQS中：唤醒后驱节点线程的方法
    private void unparkSuccessor(Node node) { 
       	// 获取当前node节点的waitStatus状态
        int ws = node.waitStatus;
        
        if (ws < 0)// -1：SIGNAL 
            // 改成0的原因：因为当前节点已经完成唤醒后驱节点线程的任务了~
            compareAndSetWaitStatus(node, ws, 0);
        // s是当前节点的第一个后驱节点
        Node s = node.next;
        
        // 条件1：s == null
        // s 什么时候为null？
        // 1.当前节点就是tail节点时，s==null
        // 2.当前节点入队未完成时（1.设置新节点的prev指向pred 2.CAS设置新节点为tail 3.(未完成)pred.next -> 新节点）
        // 需要找到可以被唤醒的节点...
        
        // 条件2：s.waitStatus > 0 前提是 s == null
        // 如果条件2成立，则说明当前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;
            // 上面的循环，会找到一个离当前node最近的一个可以被唤醒的节点，该节点可能找不到，可能是null
        }
        
        // 如果找到合适的，且可以被唤醒的节点s，则将其挂起，如果没找到，则什么也不做~
        if (s != null)
            LockSupport.unpark(s.thread);
    }

上一篇文章：[AQS源码探究\_03 成员方法解析(加锁、资源竞争逻辑)][AQS_03] 和 本篇文章的前面部分，都是在介绍ReentrantLock的`lock()`加锁方式，这种加锁方式是**不可以被响应中断的**，下面我们分析**可以被响应中断**的加锁方式`lockInterruptibly()`：

## 扩展：AQS成员方法解析(响应中断加锁逻辑) ##

### 1. lockInterruptibly可以被响应中断的加锁方法 ###

// 位于ReentrantLock中：可以被响应中断的加锁方法
    public void lockInterruptibly() throws InterruptedException { 
        // 可以被响应中断的方式去竞争资源~
        sync.acquireInterruptibly(1);
    }
    
    // 位于AQS的Sync静态内部类中：竞争资源的方法(可以被响应中断)
    public final void acquireInterruptibly(int arg)
            throws InterruptedException { 
        // 如果当前线程已经是有中断标记interrupted为true了，则直接抛出中断异常~
        if (Thread.interrupted())
            throw new InterruptedException();
        // 尝试获取锁
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }
    
    private void doAcquireInterruptibly(int arg)
        throws InterruptedException { 
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try { 
            for (;;) { 
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) { 
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally { 
            if (failed)
                // 我们主要来分析下cancelAcquire这个方法: 取消指定node参与竞争。
                cancelAcquire(node);
        }

### 2. cancelAcquire取消指定node参与竞争的方法 ###

// 位于AQS下
    /** * 取消指定node参与竞争。 */
    private void cancelAcquire(Node node) { 
        //空判断..
        if (node == null)
            return;
    
        //因为已经取消排队了..所以node内部关联的当前线程，置为Null就好了。。
        node.thread = null;
    
        //获取当前取消排队node的前驱。
        Node pred = node.prev;
    
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;
    
        //拿到前驱的后继节点。
        //1.当前node
        //2.可能也是 ws > 0 的节点。
        Node predNext = pred.next;
    
        //将当前node状态设置为 取消状态 1
        node.waitStatus = Node.CANCELLED;
        /** * 当前取消排队的node所在 队列的位置不同，执行的出队策略是不一样的，一共分为三种情况： * 1.当前node是队尾 tail -> node * 2.当前node 不是 head.next 节点，也不是 tail * 3.当前node 是 head.next节点。 */
        //条件一：node == tail 成立：当前node是队尾 tail -> node
        //条件二：compareAndSetTail(node, pred) 成功的话，说明修改tail完成。
        if (node == tail && compareAndSetTail(node, pred)) { 
            //修改pred.next -> null. 完成node出队。
            compareAndSetNext(pred, predNext, null);
        } else { 
            //保存节点 状态..
            int ws;
            //第二种情况：当前node 不是 head.next 节点，也不是 tail
            //条件一：pred != head 成立， 说明当前node 不是 head.next 节点，也不是 tail
            //条件二： ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL)))
            //条件2.1：(ws = pred.waitStatus) == Node.SIGNAL 成立：说明node的前驱状态是 Signal 状态 不成立：前驱状态可能是
            // 极端情况下：前驱也取消排队了..
            //条件2.2:(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))
            // 假设前驱状态是 <= 0 则设置前驱状态为 Signal状态..表示要唤醒后继节点。
            //if里面做的事情，就是让pred.next -> node.next ,所以需要保证pred节点状态为 Signal状态。
            if (pred != head &&
                    ((ws = pred.waitStatus) == Node.SIGNAL ||
                            (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                    pred.thread != null) { 
                //情况2：当前node 不是 head.next 节点，也不是 tail
                //出队：pred.next -> node.next 节点后，当node.next节点 被唤醒后
                //调用 shouldParkAfterFailedAcquire 会让node.next 节点越过取消状态的节点
                //完成真正出队。
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
    
            } else { 
                //当前node 是 head.next节点。 更迷了...
                //类似情况2，后继节点唤醒后，会调用 shouldParkAfterFailedAcquire 会让node.next 节点越过取消状态的节点
                //队列的第三个节点 会 直接 与 head 建立 双重指向的关系：
                //head.next -> 第三个node 中间就是被出队的head.next 第三个node.prev -> head
                unparkSuccessor(node);
            }
            node.next = node; // help GC
        }
    }

### 3. parkAndCheckInterruptpark当前线程方法 ###

//AQS#parkAndCheckInterrupt
    //park当前线程 将当前线程 挂起，唤醒后返回当前线程是否为中断信号唤醒。
    private final boolean parkAndCheckInterrupt() { 
        // 挂起当前线程
        LockSupport.park(this);
        // 返回当前线程的中断标识
        return Thread.interrupted();
    }

## 小结 ##

下面总结一下前面几篇文章的主要内容：

（1）AQS是Java中几乎所有锁和同步器的一个基础框架，这里说的是“几乎”，因为有极个别确实没有通过AQS来实现；

（2）AQS中维护了一个队列，这个队列使用双链表实现，用于保存等待锁排队的线程；

（3）AQS中维护了一个状态变量，控制这个状态变量就可以实现加锁解锁操作了；

（4）基于AQS自己动手写一个锁非常简单，只需要实现AQS的几个方法即可。

[AQS_03]: https://csp1999.blog.csdn.net/article/details/116374686