AQS之独占锁

Lock  lock = new ReentrantLock();
lock.lock();
try{
    xx.doXX
}finnally{
    lock.unlock();
}

public void lock() {
    sync.lock();
}

public ReentrantLock() {
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

// ReentrantLock#lock
public void lock() {
    sync.lock();
}

// FairSync#lock
final void lock() {
    acquire(1);
}

// AbstractQueuedSynchronizer#acquire
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 获取全局状态
    int c = getState();
    // state == 0 代表当前可以获取锁
    if (c == 0) {
        // hasQueuedPredecessors用于判断CLH队列中是有节点在排队，判断条件 head != tail  && (head.next == null || head.next.thread != Thread.currentThread())，head != tail说明不是初始化的那个节点；如果有下一个节点，还需要判断那个节点的thread是否和当前线程相同，如果相同，说明可以重入，此时可以获取锁
        // 通过CAS操作设置state
        // setExclusiveOwnerThread 用于保存当前线程到`exclusiveOwnerThread`属性，如果以上条件都满足，则获取锁成功
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果是锁重入，则需要更新state的值
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    否则返回失败
    return false;
}

private Node addWaiter(Node mode) {
    // 将当前线程封装成Node节点
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;

    // 如果尾节点存在，需要做的就是通过CAS操作将当前节点设置成尾节点
    if (pred != null) {
        // 1. 当前节点的前置指针指向尾节点；2. 通过CAS操作将当前节点设置成尾节点；3. 将之前的尾节点的后置指针指向当前节点(尾节点)
        node.prev = pred;

        // 如果 compareAndSetTail(pred, node) 失败，说明在这一时刻存在线程竞争，将交由enq方法中的自旋处理
        if (compareAndSetTail(pred, node)) {
            // 将之前的尾节点的后置指针指向当前节点(尾节点) ，如果线程1在下面这行代码之前被挂起，而线程2通过netx指针遍历，会出现 next== null 的情况，遇到这种情况需要通过prev指针进行反向遍历
            pred.next = node;
            return node;
        }
    }

    // 如果尾节点等于null，说明这个节点是第一个入队的节点，此时需要做一些初始化操作
    enq(node);
    return node;
}


private Node enq(final Node node) {
    // 自旋。考虑一下这里为啥要自旋处理？主要是为了处理addWaiter方法中设置为尾节点失败的情况，当两个线程同时进入addWaiter方法，如果第一个线程通过CAS操作设置尾节点成功，第二个线程通过CAS操作设置尾节点则必然失败，此时将会通过自旋的方式设置尾节点
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                // // 到这里说明这个节点是第一个入队的节点，此时需要做一些初始化操作：tail = head
                tail = head;
        } else {
            // 和addWaiter方法中的那部分逻辑一样，就是将当前节点设置成尾节点，然后设置前后指针   
            // 但这里可能会有一个问题，在这个循环体中，因为是通过cas操作设置尾节点，所以可以保证其是安全，同时可以保证其前后驱节点是正确的。但加入线程1执行到 t.next = node 时被挂起，然线程2开始从head节点开始遍历，此时 next 节点可能为空

            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        // 前面说过，这个方法的返回值表示在线程等待获取锁的过程中，是否发生了中断，就是用这个interrupted变量
        boolean interrupted = false;

        // 自旋， 直到获取锁，或者被取消，但什么时候会取消呢？
        for (;;) {
            // p代表当前节点的前置节点
            final Node p = node.predecessor();

            // p == head 并且 尝试获取锁成功，说明此时可以获取锁。为什么要 前置节点 == head 这个条件呢？
            // 我们想一下CLH队列的特点，当我们只向队列中添加了一个节点的时候，此时队列中会有两个节点(初始化的时候创建了一个节点)，此时我们添加的那个节点的前置指针指向的就是head，head的后置指针指向的是我们添加的那个节点
            // 这说明在CLF队列中，head节点是不参与竞争的，它的作用类似于一个逻辑节点，head.nex代表的那个节点，就是可以获得锁的那个节点，理解这一点很关键
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设置为head节点，同时设置 `node.thread = null;node.prev = null;` 设置这个的目的是为了将之前的那个head节点从当前列表的脱离，help GC
                setHead(node);
                // 这个步骤执行之后， head 就完成脱离队列了
                p.next = null; // help GC

                failed = false;
                return interrupted;
            }

            // 当上面的条件不满足，也就是说没有获得锁的情况，需要将当前线程阻塞。shouldParkAfterFailedAcquire方法在前驱线程阻塞的情况下会返回true，如果不返回true，这里将一直自旋；返回true之后，该线程将被阻塞
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
             // 获取锁失败，此时需要取消排队，但是我不知道在什么情况下会执行到这里
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取钱去节点的 waitStatus 值
    int ws = pred.waitStatus;

    // 如果前驱节点正在阻塞中，直接返回true
    if (ws == Node.SIGNAL)
        /*
            * This node has already set status asking a release
            * to signal it, so it can safely park.
            */
        return true;

    // waitStatus 大于0的情况只有一种，就是 CANCELLED，此时需要将该节点从CLF队列中移除
    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.
         */
        // 如果是其他情况，需要将前驱节点的 waitStatus 设置为 阻塞状态，然后返回false
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
    // 阻塞当前线程
    LockSupport.park(this);
    // 判断当前线程是否发生中断
    return Thread.interrupted();
}

// ReentrantLock#unlock
public void unlock() {
    sync.release(1);
}

// AbstractQueuedSynchronizer#release
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    // 释放锁的时候，state - 1
    int c = getState() - releases;

    // 如果 hread.currentThread() != getExclusiveOwnerThread() 说明，当前线程没有获得锁，因此不能释放，此时抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;

    // 如果 c==0 说明此时没有重入了，需要对 `上一个节点对应的线程` 进行解除阻塞操作，此时返回true
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }

    // 设置 state 的值，这里不存在竞争关系，所以不需要通过CAS操作
    setState(c);
    return free;
}

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)
        compareAndSetWaitStatus(node, 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;
    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);
}

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

final boolean acquireQueued(final Node node, long arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 什么情况下会执行呢？
            cancelAcquire(node);
    }
}