JDK源码阅读计划(Day14&15) AQS

JDK11

AQS

JDK并发包中的CountDownLatch,ReentrantLock,ThreadPoolExecutor,Semaphore,ReentrantReadWriteLock 都是继承自AbstractQueuedSynchronizer这个抽象类，其本质使用一个双向链表维护一个FIFO队列，用state来维护资源的状态以此用于实现上面那些子类的锁语义。

若被请求的共享资源空闲，则会把当前请求资源的线程设置为有效的工作线程，并且把共享资源设置为锁定状态。如果被请求的共享资源被占用，就把线程封装为Node加入到一个虚拟队列中，具体是通过CLH队列锁的方式实现。CLH本质上是用前一结点某一属性表示当前结点的状态。

那么在这些子类中资源分别表示什么意思呢？这里参考ref给出一个表格

AQS有两种队列，一种是同步队列，一种是条件队列


同步队列是一个双向链表，而条件队列只有在使用Condition的时候才会创建，是一个单向队列。至于两者怎么用，得要等到后面才介绍了。队列中的结点本质上是对线程的包装，分为独享型和共享型两种:

继承关系

public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements Serializable

可以看见继承关系并不复杂，我们首先来看其抽象父类AbstractOwnableSynchronizer的代码

AbstractOwnableSynchronizer

提供了设置独占线程核获取独占线程的方法

public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {

    /** Use serial ID even though all fields transient. */
    private static final long serialVersionUID = 3737899427754241961L;

    /**
     * Empty constructor for use by subclasses.
     */
    protected AbstractOwnableSynchronizer() { }

    /**
     * The current owner of exclusive mode synchronization.
     */
    private transient Thread exclusiveOwnerThread;

    /**
     * Sets the thread that currently owns exclusive access.
     * A {@code null} argument indicates that no thread owns access.
     * This method does not otherwise impose any synchronization or
     * {@code volatile} field accesses.
     * @param thread the owner thread
     */
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    /**
     * Returns the thread last set by {@code setExclusiveOwnerThread},
     * or {@code null} if never set.  This method does not otherwise
     * impose any synchronization or {@code volatile} field accesses.
     * @return the owner thread
     */
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

内部类

Node

static final class Node

作为同步队列与条件队列的结点。每一个等待锁的线程会封装成一个Node放入队列，每个Node有一个对Thread的引用，所以实际上是Thread在排队，然后每个Node还有一个waitStatus，用来表示线程的状态。

• Marker用于标志模式

/** Marker to indicate a node is waiting in shared mode */
static final Node SHARED = new Node();  // 【共享】模式
/** Marker to indicate a node is waiting in exclusive mode */
static final Node EXCLUSIVE = null;     // 【独占】模式

• 四种状态码

/*
* 该标记指示结点应当被取消，不再参与排队
* 如果在线程阻塞期间发生异常的话，会为其所在的结点设置此标记
*/
static final int CANCELLED = 1;

// SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark
static final int SIGNAL = -1;

// CONDITION，值为-2，表示当前节点在条件队列中
static final int CONDITION = -2;

/* 当一个共享结点没有经过阻塞就直接获取锁时，
* 会将头结点更新为该结点，并且为该结点设置PROPAGATE标记，
* 接下来，如果其后续结点也不需要经过阻塞，那么该结点保持PROPAGATE标记，
* 反之，如果其后续结点需要经过阻塞，那么该标记会被修改为SIGNAL
* /
* //只会在队列的头节点设置
static final int PROPAGATE = -3;

状态默认为0，表示结点在同步队列中

• 线程可见的状态码

volatile保证线程可见

volatile int waitStatus;

• Thread引用

 // node内存储的线程引用，表面上是node在排队，实际上是thread在排队
volatile Thread thread;

• 前驱和后继

// 用于【|同步队列|】，表示排队结点的后继，顺着后继遍历可以找到陷入阻塞的node线程
volatile Node next;
volatile Node prev;

• 下一个结点

/*
* 用于【|同步队列|】时，该引用仅作为标记使用
 * 它表示参与排队的node是[独占模式node]，或者是[共享模式node]
 *
 * 用于【|条件队列|】时，该引用表示参与排队的下一个结点
 */
Node nextWaiter;

• 构造函数

 /** Establishes initial head or SHARED marker. */
// 创建一个空的Node，用作头结点或共享标记
Node() {
}

/** Constructor used by addWaiter. */
// 创建一个独占/共享模式的node
Node(Node nextWaiter) {
    this.nextWaiter = nextWaiter;   // 记录当前node的模式
    THREAD.set(this, Thread.currentThread());   // 继续当前线程
}

/** Constructor used by addConditionWaiter. */
// 创建一个状态为waitStatus的node
Node(int waitStatus) {
    WAITSTATUS.set(this, waitStatus);
    THREAD.set(this, Thread.currentThread());
}

ConditionObject

public class ConditionObject implements Condition, Serializable

这个类方法比较多，具体实现等会再分析，不过我们可以从继承关系推断，这个类相当于AQS内部的Condition，提供wait,signal等线程通信的操作。

// {同步条件}对象，用于更精细地指导线程的同步行为
public class ConditionObject implements Condition, Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    
    /** Mode meaning to reinterrupt on exit from wait */
    // 刚刚唤醒的线程带有中断标记，且该线程node仍在【|条件队列|】，此时需要为线程恢复中断标记
    private static final int REINTERRUPT = 1;
    
    /** Mode meaning to throw InterruptedException on exit from wait */
    // 刚刚唤醒的线程带有中断标记，且该线程node已进入了【|同步队列|】，此时需要抛出异常
    private static final int THROW_IE = -1;
    
    // 【|条件队列|】以单链表形式组织，firstWaiter和lastWaiter是首尾结点，不存在头结点
    private transient Node firstWaiter, lastWaiter;

重要方法

tryAcquire

// 申请独占锁，允许阻塞带有中断标记的线程（会先将其标记清除）
public final void acquire(int arg) {
    // 尝试申请独占锁
    if(!tryAcquire(arg)){
        /*
         * 如果当前线程没有申请到独占锁，则需要去排队
         * 注：线程被封装到Node中去排队
         */
        
        // 向【|同步队列|】添加一个[独占模式Node](持有争锁线程)作为排队者
        Node node = addWaiter(Node.EXCLUSIVE);
        
        // 当node进入排队后再次尝试申请锁，如果还是失败，则可能进入阻塞
        if(acquireQueued(node, arg)){
            // 如果线程解除阻塞时拥有中断标记，此处要进行设置
            selfInterrupt();
        }
    }
}

• 调用tryAcquire函数，调用此方法的线程会尝试申请独占锁。在AQS中该方法会抛异常，并没有实现，需要由子类实现。

• 如果失败，说明线程没有申请到独占锁，需要以结点形式加入到同步队列末尾

• 排队之后再次尝试申请锁，如果还是失败线程就阻塞

我们重点来看其中涉及到的方法：

addWaiter

尾插加入同步队列末尾

/*
* 向【|同步队列|】添加一个排队者(线程)
*
* mode有两种可能：
* 1.独占模式：Node.EXCLUSIVE
* 2.共享模式：Node.SHARED
* 由此，可创建[独占模式Node]或[共享模式Node]
* 创建的[模式Node]会记下当前线程的引用，并进入同步队列进行排队
*/
private Node addWaiter(Node mode) {
   // 创建一个独占/共享模式的node，该node存储了当前线程的引用
   Node node = new Node(mode);
   
   // 使用尾插法将node添加到【|同步队列|】
   enq(node);
   
   // 返回刚加入【|同步队列|】的[模式Node]
   return node;
}

enq

// 使用尾插法将node添加到【|同步队列|】，并返回旧的队尾
private Node enq(Node node) {
     for(; ; ) {
         Node oldTail = tail;
         if(oldTail != null) {
             // 设置node的前驱为oldTail
             node.setPrevRelaxed(oldTail);
             
             // 更新队尾游标指向node
             // oldTail为tail的引用,这里的CAS是把oldTail地址对应的值设置为node，相当于tail = node;
             if(compareAndSetTail(oldTail, node)) {
                 // 链接旧的队尾与node，形成一个双向链表
                 oldTail.next = node;
                 return oldTail;
             }
         } else {
             // 【|同步队列|】不存在时，需要初始化一个头结点
             initializeSyncQueue();
         }
     }
 }

acquireQueued

进入同步队列后的结点尝试抢锁，只有当前结点是头节点才有抢锁资格。
如果失败，则会调用shouldParkAfterFailedAcquire 判断能否挂起线程，然后调用parkAndCheckInterrupt挂起当前线程

// 当node进入排队后再次尝试申请锁，如果还是失败，则可能进入阻塞
    final boolean acquireQueued(final Node node, int arg) {
        
        // 记录当前线程从阻塞中醒来时的中断标记（阻塞(park)期间也可设置中断标记）
        boolean interrupted = false;
        
        try {
            /*
             * 死循环，成功申请到锁后退出
             *
             * 每个陷入阻塞的线程醒来后，需要重新申请锁
             * 只有当自身排在队首时，才有权利申请锁
             * 申请成功后，需要丢弃原来的头结点，并将自身作为头结点，然后返回
             */
            for(; ; ) {
                // 获取node结点的前驱
                final Node p = node.predecessor();//返回AQS的prev
                
                // 如果node结点目前排在了队首，则node线程有权利申请锁
                if(p == head) {
                    // 再次尝试申请锁
                    if(tryAcquire(arg)){
                        // 设置node为头结点（即丢掉了原来的头结点）
                        setHead(node);
                        
                        // 切断旧的头结点与后一个结点的联系，以便GC
                        p.next = null;
                        
                        // 返回线程当前的中断标记（如果线程在阻塞期间被标记为中断，这里会返回true）
                        return interrupted;
                    }
                }
                
                // 抢锁失败时，尝试为node的前驱设置阻塞标记（每个结点的阻塞标记设置在其前驱上）
                if(shouldParkAfterFailedAcquire(p, node)) {
                    /*
                     * 使线程陷入阻塞
                     *
                     * 如果首次到达这里时线程被标记为中断，则此步只是简单地清除中断标记，并返回true
                     * 接下来，通过死循环，线程再次来到这里，然后进入阻塞(park)...
                     *
                     * 如果首次到达这里时线程没有被标记为中断，则直接进入阻塞(park)
                     *
                     * 当线程被唤醒后，返回线程当前的中断标记（阻塞(park)期间也可设置中断标记）
                     */
                    interrupted |= parkAndCheckInterrupt();
                }
            }
        } catch(Throwable t) {
            // 如果中途有异常发生，应当撤销当前线程对锁的申请
            cancelAcquire(node);
            
            // 如果发生异常时拥有中断标记，此处要进行设置
            if(interrupted) {
                selfInterrupt();
            }
            
            throw t;
        }
    }

shouldParkAfterFailedAcquire

当入队的结点抢锁失败之后，调用该函数判断线程是否应该挂起

/*
     * 抢锁失败时，尝试为node的前驱设置阻塞标记
     *
     * 每个结点的阻塞标记设置在其前驱上，原因是：
     * 每个正在活动的结点都将成为头结点，当活动的结点（头结点）执行完之后，
     * 需要根据自身上面的阻塞标记，以确定要不要唤醒后续的结点
     *
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // node前驱的状态
        int ws = pred.waitStatus;
        
        // 如果node前驱的状态为Node.SIGNAL，则表示node需要进入阻塞状态
        if(ws == Node.SIGNAL){
            /* This node has already set status asking a release to signal it, so it can safely park. */
            
            // 只有前驱节点为SIGNAL才能调用park阻塞线程
            return true;
        }
        
        // 如果node前驱的状态被标记为取消，则顺着其前驱向前遍历，将紧邻的待取消结点连成一片
        if(ws>0) {
            /* Predecessor was cancelled. Skip over predecessors and indicate retry. */
            do {
                node.prev = pred = pred.prev;
            } while(pred.waitStatus>0);
            
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.
             * Indicate that we need a signal, but don't park yet.
             * Caller will need to retry to make sure it cannot acquire before parking.
             */
            // 更新node前驱的状态为Node.SIGNAL，即使node陷入阻塞
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        
        return false;
    }

parkAndCheckInterrupt

阻塞线程的方法封装在这个函数中
首先执行park操作，即禁用当前线程，然后返回该线程是否已经被中断

// 设置线程进入阻塞状态，并清除线程的中断状态。返回值代表之前线程是否处于阻塞状态
private final boolean parkAndCheckInterrupt() {
    // 设置线程阻塞（对标记为中断的线程无效）
    LockSupport.park(this);
    return Thread.interrupted();//会清除中断标志位
}

cancelAcquire

如果acquireQueued抛异常，就要调用这个方法设置当前Node为CANCELLED，使其丧失获得资源的资格

 // 标记node结点为Node.CANCELLED（取消）状态
    private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if(node == null) {
            return;
        }
        
        // 删除对线程的引用,方便GC
        node.thread = null;
        
        // Skip cancelled predecessors
        Node pred = node.prev;
        // 顺着node的前驱向前遍历，将标记为取消的node结点连成一片
        while(pred.waitStatus>0) { //CANCELLED  = 1
            node.prev = pred = pred.prev;
        }
        
        // predNext is the apparent node to unsplice.
        // CASes below will fail if not, in which case, we lost race vs another cancel or signal,
        // so no further action is necessary, although with a possibility that a cancelled node may transiently remain reachable.
        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线程进入取消状态
        node.waitStatus = Node.CANCELLED;
        
        // If we are the tail, remove ourselves.
        // 如果当前节点是尾节点，把pred设置成tail
        if(node == tail && compareAndSetTail(node, pred)) {
            // 把predNext即当前Node设为null
            pred.compareAndSetNext(predNext, null);
        } 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 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL)))
                && pred.thread != null) {
                Node next = node.next;
                // 将处于阻塞状态的node连成一片，通过后继向后遍历即可获得
                if(next != null && next.waitStatus<=0) {
                    //pred.next = next 相当于把node忽略掉
                    pred.compareAndSetNext(predNext, next);
                }
            } else {
                // 唤醒node后面陷入阻塞的“后继”
                unparkSuccessor(node);
            }
            
            node.next = node; // node后继指向自身，目的是为了便于GC,因为再也没有别的引用指向Node了
        }
    }

结合下面这张图来理解，cancelAcquire以Node为参数，把其状态设置为CANCELLED,并且向前遍历把直到找到SIGNAL的结点，中间CANCELLED的所有节点都会被移除这个同步队列。然后调用unparkSuccessor尝试唤醒node的下一个正在阻塞的结点。

/*
 * 唤醒node后面陷入阻塞的“后继”
 *
 * 注：
 * 由于有些结点可能会被标记为Node.CANCELLED（取消），
 * 所以这里的后继可能不是node.next，需要进一步搜索后才能确定
 */
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) {
        // 如果node状态码为负，则将其重置为0
        node.compareAndSetWaitStatus(ws, 0);
    }
    
    /*
     * 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;
    /*
     * 如果s==null，说明node已经是尾结点，后面没有需要唤醒的结点了
     *
     * 如果s!=null，且s.waitStatus>0，说明node被标记为Node.CANCELLED（取消）
     * 此时，需要从尾端向前遍历，找到离s最近的正处于阻塞的后继，以便后续唤醒它
     */
    if(s == null || s.waitStatus>0) {
        s = null;
        for(Node p = tail; p != node && p != null; p = p.prev) {
            if(p.waitStatus<=0) {
                s = p;
            }
        }
    }
    
    // 唤醒node的后继
    if(s != null) {
        LockSupport.unpark(s.thread);
    }
}

一个不允许中断带有中断标志的线程的acquire方法都那么复杂了…源码还有几个允许中断的方法，还有几个带超时参数的方法，以后再说吧，但是大概思路和上面是一样的

Release

// 释放锁，如果锁已被完全释放，则唤醒后续的阻塞线程。返回值表示本次操作后锁是否自由
public final boolean release(int arg) {
    // 释放一次锁，返回值表示同步锁是否处于自由状态（无线程持有）
    if(tryRelease(arg)) {
        /* 如果锁已经处于自由状态，则可以唤醒下一个阻塞的线程了 */
        
        Node h = head;
        if(h != null && h.waitStatus != 0) {
            // 唤醒h后面陷入阻塞的“后继”
            unparkSuccessor(h);
        }
        
        return true;
    }
    
    return false;
}

tryRelease在AQS中没有实现，需要依赖子类来实现

acquire和release方法相当于实现了锁中lock和unlock的操作

acquire总结起来就是当前线程尝试去抢占锁，如果抢不了就以Node形式加入到队列中，再尝试抢一次，抢不到就挂起阻塞

然后之后AQS具体怎么用，就要看其子类的源码的时候再给出相关源码了。至于contentObject方法得具体实现，可能要到看ReentrantLock和ReentrantReadWriteLock的时候再介绍了

ref

https://juejin.im/post/5ae754af518825672a02b498
https://www.cnblogs.com/leesf456/p/5350186.html
https://editor.csdn.net/md/?articleId=106038954