并发和多线程(九)--AbstractQueuedSynchronizer基本原理

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    
}

private transient Thread exclusiveOwnerThread;

//同步队列的头结点
private transient volatile Node head;

//同步队列的尾结点
private transient volatile Node tail;

//当前锁的状态，需要子类去实现，例如0表示可以获取锁，1表示当前锁被持有，无法获取(排他)，共享锁模式下，state>0表示持有锁线程的数量
private volatile int state;

//旋转超时阈值，设置等待超时时间才生效
static final long spinForTimeoutThreshold = 1000L;

public class ConditionObject implements Condition, java.io.Serializable {
    //条件队列的头结点
    private transient Node firstWaiter;
    //条件队列的尾结点
    private transient Node lastWaiter;
}

public final void acquire(int arg) {
    //tryAcquire：在AQS中默认抛出异常，需要子类去实现，子类一般选择非public的内部类去实现AQS，表示当前是否获取到锁，如果获取到锁，直接结束执行
    //addWaiter：当前没有获取到锁，将线程添加到同步队列尾部
    //acquireQueued：阻塞当前节点
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        //自我打断
        selfInterrupt();
}

// 尝试获取锁，如果状态为0，获取到锁，更新state为1(1代表exclusive模式下锁已经被持有)
public boolean tryAcquire(int acquires) {
    //CAS实现赋值
    if (compareAndSetState(0, acquires)) {
        //将当前线程set到AbstractOwnableSynchronizer中的exclusiveOwnerThread，为了方便跟踪获得锁的线程
//                ，可以帮助监控工具识别哪些线程持有锁。
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}

//acquire方法为EXCLUSIVE独占锁模式
addWaiter(Node.EXCLUSIVE);

private Node addWaiter(Node mode) {
    //将当前线程，封装成一个EXCLUSIVE模式的节点
    Node node = new Node(Thread.currentThread(), mode);
    //取出尾结点
    Node pred = tail;
    //
    if (pred != null) {
        //tail赋值给当前节点的prev
        node.prev = pred;
        //如果CAS把当前node变成tail节点，返回当前节点
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //如果一次没有把当前节点放到队列中，进入自旋enq()
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
         //如果tail 为null，通过CAS进行head、tail的初始化
        if (t == null) {
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {//和之前的操作一样，只是外部是for(;;)保证入队成功
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                //注意这里return 的是当前节点的前一个节点，和上面不一样。
                return t;
            }
        }
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //ws为当前节点的前驱节点waitStatus
    int ws = pred.waitStatus;
    //如果ws已经是signal，直接返回
    if (ws == Node.SIGNAL)
        return true;
    //如果ws>0，也就是canceld状态，往前面遍历，知道找到前面不是canceld状态的节点
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //通过CAS将ws设置为signal状态
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
//通过LockSupport.park挂起线程，直到被唤醒，返回是否interrupt
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

public final boolean release(int arg) {
    //尝试去释放锁，方法由子类实现
    if (tryRelease(arg)) {
        Node h = head;
        //当前队列head不为null，外套Status不是初始状态
        if (h != null && h.waitStatus != 0)
            //唤醒head的后继节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}

//unlock方法调用，参数为1
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    //如果当前节点和AbstractOwnableSynchronizer保存的线程不相同，直接抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //如果当前state状态就是1
    if (c == 0) {
        free = true;
        //将独占线程设置为null，返回true
        setExclusiveOwnerThread(null);
    }
    //将c赋值state
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
    
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    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;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}