一文带你深入理解Java AbstractQueuedSynchronizer

// （独占式）尝试获取资源，成功则返回true，失败则返回false。
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}
// （独占式）尝试释放资源，成功则返回true，失败则返回false。
protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}
// （共享式）尝试获取资源，负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
// （共享式）尝试释放资源，成功则返回true，失败则返回false。
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}
// 判断当前线程是否正在独占式，只有用到condition才需要去实现它。
protected boolean isHeldExclusively() {
    throw new UnsupportedOperationException();
}

static final class Node {
    // 共享模式
    static final Node SHARED = new Node();
    // 独占模式
    static final Node EXCLUSIVE = null;
    // 由于超时、中断或其他原因，线程被取消
    static final int CANCELLED =  1;
    // 当前节点的后继节点阻塞等待共享资源
    static final int SIGNAL    = -1;
    // 当前节点在条件队列
    static final int CONDITION = -2;
    // 当前节点的下一个acquireShared应无条件传播
    static final int PROPAGATE = -3;
    // 节点状态
    volatile int waitStatus;
    // 前驱节点
    volatile Node prev;
    // 后继节点
    volatile Node next;
    // 节点的线程
    volatile Thread thread;
    // 下一个等待者（这个用于 Condition，这里不做过多说明）
    Node nextWaiter;
    // 是否是共享模式
    final boolean isShared() {
        return nextWaiter == SHARED;
    }
    // 获取前驱节点，为空则抛出异常
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }
    // 各种构造器
    Node() {
    }
    Node(Thread thread, Node mode) {
        this.nextWaiter = mode;
        this.thread = thread;
    }
    Node(Thread thread, int waitStatus) {
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

// 序列号
private static final long serialVersionUID = 7373984972572414691L;
// 头结点
private transient volatile Node head;
// 尾结点
private transient volatile Node tail;
// 同步状态
private volatile int state;
// 自旋时间
static final long spinForTimeoutThreshold = 1000L;
// Unsafe实例以及各种内存偏移量
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

// 获取同步状态
protected final int getState() {
    return state;
}
// 设置同步状态
protected final void setState(int newState) {
    state = newState;
}
// CAS方式设置同步状态（当期待值expect等于当前同步状态时，将同步状态设置为update值）
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

// 这里调用的是 nonfairTryAcquire(1)，也就是acquires为 1
final boolean nonfairTryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取同步状态
    int c = getState();
    // 同步状态为0，说明共享资源空闲可以直接抢占
    if (c == 0) {
        // 再次尝试抢占
        if (compareAndSetState(0, acquires)) {
            // 成功则将当前线程设置为共享资源所有者
            setExclusiveOwnerThread(current);
            // 返回 true
            return true;
        }
    }
    // 当前共享资源还在被占用，判断当前线程是不是共享资源所有者
    else if (current == getExclusiveOwnerThread()) {
        // 增加同步状态（这里其实也就是 ReentrantLock 是可重入锁的原因，如果是自己线程持有的锁，可以再次加锁，也就是可重入）
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新同步状态
        setState(nextc);
        // 返回 true
        return true;
    }
    // 如果上面情况都不是则返回 false
    return false;
}

private Node addWaiter(Node mode) {
    // 以当前线程以及 mode（这里是独占式）为参数构建节点
    Node node = new Node(Thread.currentThread(), mode);
    // 获取队列末尾节点
    Node pred = tail;
    // 判断末尾节点是否为空
    if (pred != null) {
        // 末尾不为空时，将当前节点链接到莫尾结点后面，并且将当前节点设置为末尾节点
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            // 返回当前节点
            return node;
        }
    }
    // 末尾节点为空，则进入 enq 方法
    enq(node);
    return node;
}

private Node enq(final Node node) {
    // 循环直到将 node 加入队列为止
    for (;;) {
        Node t = tail;
        // 判断末尾节点是否为空
        if (t == null) {
            // 为空，说明需要设置哨兵节点
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 不为空，直接加入末尾，并设置当前节点为末尾节点
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// node 为当前加入队列的节点，arg 为 1
final boolean acquireQueued(final Node node, int arg) {
    // 标志，用来判断是否执行后面的cancelAcquire方法
    // 也就是中途是否存在异常中断，有则使用cancelAcquire整理队列
    boolean failed = true;
    try {
        // 中断标志
        boolean interrupted = false;
        // 循环
        for (;;) {
            // 获取当前节点的前置节点
            final Node p = node.predecessor();
            // 判断前置节点是否是头结点（当前节点是否是队列第一个等待线程）以及再次尝试获取资源
            if (p == head && tryAcquire(arg)) {
                // 满足条件说明当前节点已经抢占到资源，可以从队列中移除
                // 所以这里会将当前节点设置为头结点（setHead方法操作是先将节点线程以及前驱节点置空）
                setHead(node);
                // 并且将原本的头结点置空，通过辅助GC回收
                p.next = null; // help GC
                // 标志置为false，表示没有异常
                failed = false;
                // 返回中断标志
                return interrupted;
            }
            // 上述条件不满足，则执行shouldParkAfterFailedAcquire和parkAndCheckInterrupt
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 整理队列，将队列中中断的进程移除
            cancelAcquire(node);
    }
}

// 传参 pred 为当前节点的前置节点；node 为 当前节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取前置节点的状态
    int ws = pred.waitStatus;
    // 判断是不是 Node.SIGNAL（-1）
    if (ws == Node.SIGNAL)
        // 状态为-1表示线程已经准备好了（阻塞等待了），就等资源释放进行争抢了
        // 返回 true 执行 parkAndCheckInterrupt() 方法（这玩意就是阻塞线程）
        return true;
    // 判断状态是否大于0，表示被中断
    if (ws > 0) {
        //前置节点为被中断，意味着这个节点没用了，需要再往前找，找到不是被中断的状态为止
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 找到后将新的前置节点与当前节点链接起来
        pred.next = node;
    } else {
        // CAS 方式将前置节点的状态设置为 Node.SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回 false 直接跳出
    return false;
}

private final boolean parkAndCheckInterrupt() {
    // 调用 LockSupport 类进行阻塞当前线程
    LockSupport.park(this);
    // 返回当前线程是否中断，同时清除中断标志位
    return Thread.interrupted();
}

// 参数为当前节点
private void cancelAcquire(Node node) {
    // 当前节点为空直接返回
    if (node == null)
        return;
    // 将当前节点的线程置空
    node.thread = null;
    // 这一步是找到当前节点的前驱节点
    Node pred = node.prev;
    // 如果前驱节点状态也为 CANCELLED 则循环找前驱节点的前驱节点直到状态不为 CANCELLED
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;
    // 获取前驱节点的下一个节点
    Node predNext = pred.next;
    // 将当前节点设置为 CANCELLED
    node.waitStatus = Node.CANCELLED;
    // 判断当前节点是否是末尾节点，是则只需要将末尾节点设置成获取到的前驱节点即可
    // 相当于移除掉了前驱节点后的所有节点
    if (node == tail && compareAndSetTail(node, pred)) {
        // 并将前驱节点的下一节点置空
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
        // 满足三个条件
        // 1. 前驱节点不是头结点
        // 2. 前驱节点的状态为 SIGNAL 或者 前驱节点状态小于0并且可以设置为 SIGNAL
        // 3. 前驱节点的线程不为空
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            // 保存当前节点的后继节点
            Node next = node.next;
            // 后继节点不为空并且状态不为 CANCELLED
            if (next != null && next.waitStatus <= 0)
                // 将前驱节点与后继节点链接起来，移除中间的节点
                compareAndSetNext(pred, predNext, next);
        } else {
            // 以上条件不满足则唤醒当前线程的下一个节点
            unparkSuccessor(node);
        }
        // 辅助GC回收
        node.next = node; // help GC
    }
}

protected final boolean tryRelease(int releases) {
    // 传入releases 为 1, getState() 为 1
    // 所以 c = 1 - 1 = 0
    int c = getState() - releases;
    // 判断当前线程是否是共享资源所有者，不是则抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 判断c是否等于0，共享资源是否空闲
    if (c == 0) {
        // 更新free标志
        free = true;
        // 将共享资源所有者置空
        setExclusiveOwnerThread(null);
    }
    // 更新state
    setState(c);
    // 返回free标志
    return free;
}

private void unparkSuccessor(Node node) {
    // 获取当前结点的状态
    int ws = node.waitStatus;
    // 判断是否小于0，重新将状态置为0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 获取当前结点的后继节点
    Node s = node.next;
    // 如果后继节点为空或者后继节点状态为 CANCELLED
    if (s == null || s.waitStatus > 0) {
        // 后继节点置空
        s = null;
        // 通过从后向前遍历找到离当前节点最近的后一个节点并且该节点状态小于0
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                // 如果状态小于0说明已经准备好获取资源了，替换掉原先的后继节点
                s = t;
    }
    // 后继节点不为空
    if (s != null)
        // 唤醒该后继节点的线程
        LockSupport.unpark(s.thread);
}