AQS和ReentrantLock

AQS子类

继承于AQS的子类。

ReentrantLock

在ReentrantLock中的lock方法

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

就是对Sync类的调用。

锁的获取

大体的思路，就是先尝试获取一个锁，如果失败，说明锁正在被人占着，这时候需要把当前线程放到一个容器里，然后挂起。
下面看看具体的实现是啥。

如果是非公平锁

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

在AQS类中有个state状态，用cas去改变他， 0代表空闲，1代表正在被占用。这个就相当于一个锁。

private volatile int state;

如果state=0的话，代表当前锁没有被任何线程锁起来。
所以首先尝试获取这个锁，如果成功了，那么把当前的独占线程设为当前线程。

不然，调用acquire方法，加1。为什么加1呢，因为ReentantLock是可重入锁，同一个线程每一次获取都是加1，每一次释放就减1。下面我们会看到。

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

acquire方法在AQS中。
但是tryAcquire是交给子类去实现的。

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

因为是非公平锁，所以调用nonfairTryAcquire。

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

在nonfairTryAcquire中，先再次尝试获取一下state。
如果失败，再判断下当前的独占线程是不是自己，如果是自己，就把acquire加上去。
这里就是可重入的逻辑。

如果获取失败，而且当前独占线程也不是自己，那么返回false。
再返回到AQS中的acquire逻辑，if中第一个条件失败了，那么执行第二个条件acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，就是把当前线程丢到一个等待锁的容器中并挂起。

Node的mode有下面这几种

//独占
static final Node EXCLUSIVE = null;
//这个线程取消获取锁
static final int CANCELLED =  1;
static final int SIGNAL    = -1;
//这个线程在等待某个条件
static final int CONDITION = -2;
//节点唤醒需要向下传播，和读写锁有关
static final int PROPAGATE = -3;

上面调用的是独占的EXCLUSIVE。

private transient volatile Node tail;
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

看到node应该可以猜到这个放等待线程的容器是链表。
先cas尝试一下把当前线程包装的node放到末尾。
如果失败进入enq()中。

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

enq的逻辑就是不断自旋，cas加到末尾。其中也包含了head未初始化的情况。

好，现在成功加到末尾，调用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; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

node.predecessor得到的是节点的prev节点。
这里假设当前节点前面有很多节点，那么第一个条件肯定不满足，进入到第二个if中。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) {
        //表示前一个线程已经取消获取锁
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //如果状态为0或者为PROPAGATE
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

判断前一个节点的waitStatus。
如果是SIGNAL，返回true
如果大于0，那就是cancelled了，那就跳过
不然就是cas把当前的pred的node的waitStatus设为SIGNAL

如果成功

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

那么parkAndCheckInterrupt就把当前线程挂起。

释放锁

在unLock中

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

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}
  
  
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

tryRelease方法，就是把state减掉，然后把当前的独占线程置空。
在回到release方法，那个unparkSuccessor调用。

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);
}

可以看到这里就是唤醒了下一个node节点中的等待线程。

那么ReentrantLock的公平和非公平体现在哪里呢。
我一开始以为的是head节点会唤醒所有的后缀节点，结果不是。
已经排队的节点还是按照排队顺序来唤醒。
不过在头节点唤醒时，可以有其他的线程来插队。
再回到lock方法

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

在获取失败，加到队列的过程中，也尝试了两次插队，最后都失败了，才加入到队列中。

另外，AQS的等待队列只是FIFO的，也就是说不支持优先权。

总结

AQS为独占和共享提供了基本的接口，需要我们自己去实现tryAcquire等方法。

获取锁

正常来说，如果tryAcquire失败，那么AQS就会把当前线程包在Node中，加到等待队列中。
等待队列是一个FIFO的双向链表。
如果是独占的锁，那么就很简单，ReentrantLock就是借助一个int的变量表明被占用还是空闲。
如果是共享锁，这就要看具体的情况了，在CountDownLatch中，就是看当前的钥匙是不是0，如果不是0，说明还是有线程没有countdown，那就加到等待队列去。
在读写锁中，如果当前有读锁或者写锁，那就失败。

释放锁

然后每次head节点在临界区执行完成，就会选择唤醒下一个节点。
如果是独占的，就唤醒下一个，如果是共享的，那么就唤醒下一波所有的要获取共享锁的线程。