深入理解AQS

1. 概念

设计初衷：该类利用 状态+队列 实现了一个同步器，更多的是提供一些模板方法（子类必须重写，不然会抛错）。
设计功能：独占、共享模式

2. 两个核心，state、Queue

2.1 state

setState、compareAndSetState都是用于修改同步状态。看类名其实就知道一个是线程不安全的（setState），一个是使用了乐观锁来保证线程安全（compareAndSetState）。

• 使用场景

• setState：应用于释放资源的线程，因为同一时间只有一个使用这个线程不安全的方法去修改state的值，所以不会发生并发安全问题

• compareAndSetState：应用于尝试获取同步器的资源，由于同一时间可能存在多个资源竞争锁，所以需要使用unsfte类的cas保证线程安全

private volatile int state; // 同步状态值，0：空闲，>0：有多少个线程在同步队列中等待
protected final int getState() { // 获取同步状态
    return state;
}
protected final void setState(int newState) { // 修改同步状态
    state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update); // 通过unsafe类的cas修改同步状态
}

2.2 Queue

底层：带头、尾节点的双向链表

private transient volatile Node head; // 头节点
private transient volatile Node tail; // 尾节点
static final class Node {
    volatile Node prev; // 前一个节点
    volatile Node next; // 后一个节点
}

3. 核心获取同步锁流程

3.1 acquire

public final void acquire(int arg) {
    // 尝试获取资源失败，且成功加入同步队列，则阻塞线程
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 
        selfInterrupt(); // 获取不到资源或者加入队列失败，那就中断该线程
}

3.2 tryAcquire

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException(); // 模板方法，让子类实现
}

3.3 addWaiter

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode); // 转化为同步节点（队列节点类型）
    // 尾插法
    Node pred = tail; // 指向尾节点
    if (pred != null) {
        node.prev = pred; // 新节点的前一个节点指向尾节点
        if (compareAndSetTail(pred, node)) { // 因为同时间内有多个线程进入队列，所以使用cas置换尾节点
            pred.next = node; // 原尾节点的下一个指针指向新插入的节点
            return node;
        }
    }
    enq(node); // 队列为空，需要初始化队列插入
    return node;
}

3.4 enq

private Node enq(final 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; 
            }
        }
    }
}

3.5 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; // GC掉，因为当前节点获取到资源，说明上一个节点已经执行完毕业务了
                failed = false; // 设置成功
                return interrupted; // 不阻塞
            }
            if (shouldParkAfterFailedAcquire(p, node) && // 没有获取到资源，把线程挂起，别浪费资源
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node); // 获取到资源，取消尝试获取资源
    }
}

3.6 shouldParkAfterFailedAcquire

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus; // 上一个节点的wait状态
    if (ws == Node.SIGNAL) // 上一个节点是SIGNAL状态，说明可以阻塞，回去等通知就行
        return true;
    if (ws > 0) { // 如果大于0，说明是CANCELLED状态，那就把前面那些废物节点扔掉
        do {
            node.prev = pred = pred.prev;  
        } while (pred.waitStatus > 0); // 扔啊扔，扔到前一个节点不是废物节点
        pred.next = node;
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL); // 小于0，说明前面有节点，更改成SIGNAL状态
    }
    return false;
}

3.6.1 waitStatus

static final int CANCELLED =  1; // 废弃状态，有些加入了又不想等，就玩儿
static final int SIGNAL    = -1; // 等待激活下一个节点的状态，下一个节点肯定是被Condiction.await()
static final int CONDITION = -2; // 条件状态，中间节点
static final int PROPAGATE = -3; // 共享模式下的节点状态

3.7 parkAndCheckInterrupt

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this); // 挂起当前线程
    return Thread.interrupted();
}

3.7.1 interrupted

public static boolean interrupted() {
    return currentThread().isInterrupted(true); // 获取当前线程是否为中断状态
}
private native boolean isInterrupted(boolean ClearInterrupted); // 清除中断标志

4. 获取同步锁流程图