ReentrantLock

ReentrantLock类层次结构

AbstractQueuedSynchronizer 简称AQS

AbstractQueuedSynchronizer内部使用CLH锁队列来将并发执行变成串行执行。整个队列是一个双向链表。每个CLH锁队列的节点，会保存前一个节点和后一个节点的引用，当前节点对应的线程，以及一个状态。这个状态用来表明该线程是否应该block。当节点的前一个节点被释放的时候，当前节点就被唤醒，成为头部。新加入的节点会放在队列尾部。

非公平锁的lock方法

在初始化ReentrantLock的时候，如果我们不传参数是否公平，那么默认使用非公平锁，也就是NonfairSync。这个方法先用CAS(compareAndSetState)操作，去尝试抢占该锁。如果成功，就把当前线程设置在这个锁上，表示抢占成功。如果失败，则调用acquire模板方法，等待抢占。

static final class NonfairSync extends Sync {
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
}

调用acquire(1)实际上使用的是AbstractQueuedSynchronizer的acquire方法，它是一套锁抢占的模板，总体原理是先去尝试获取锁，如果没有获取成功，就在CLH队列中增加一个当前线程的节点，表示等待抢占。然后进入CLH队列的抢占模式，进入的时候也会去执行一次获取锁的操作，如果还是获取不到，就调用LockSupport.park将当前线程挂起。那么当前线程什么时候会被唤醒呢？当持有锁的那个线程调用unlock的时候，会将CLH队列的头节点的下一个节点上的线程唤醒，调用的是LockSupport.unpark方法。 内部的实现如下:

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

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

tryAcquire 方法 可以看到实际调用了 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;
}

表明当前线程current, 并getState()拿到锁状态, 然后再次尝试CAS获取锁, 如果获取到锁就执行之前一样的cas操作. 如果还是未获取到 ->
1.判断是否是当前线程, 决定是否可重入;
2. return false; 然后开始acquireQueued流程, 但: 先通过addWaiter方法将线程加入到队列尾部节点(CLH队列)

private Node addWaiter(Node mode) {
        // 初始化一个节点，这个节点保存当前线程
        Node node = new Node(Thread.currentThread(), mode);
        // 当CLH队列不为空的视乎，直接在队列尾部插入一个节点
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        // 当CLH队列为空的时候，调用enq方法初始化队列
        enq(node);
        return node;
}
 
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;
                }
            }
        }
}

acquireQueued方法中, 如果当前节点的上一个节点p是head节点并且tryAcquire获取到锁,(获取到锁的标志就是state原来是0, 这次改成了1). 那么证明上一节点(头节点)已经释放锁(state=0了)并唤醒当前线程, 那么当前节点变成头节点,旧的赋值=null等待GC掉就行了.

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

如果本次for循环未获取到锁, 则进入到shouldParkAfterFailedAcquire方法中,

1. 如果前一个节点是SIGNAL(-1)状态, 根据下下图中的状态判断, 当前线程需要挂起. 直接返回
2. 如果是CANCELLED(取消)状态, 则需要移除. 会返回不需要挂起.
3. 如果是其它状态的话则本线程尝试设置成SIGNAL状态, 并返回不需要挂起, 从而进行第二次抢占

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            //正常-1
            return true;
        if (ws > 0) {
            //
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            //
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

当进入挂起阶段之后, 再看一下parkAndCheckInterrupt方法, 调用park直接挂起

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

非公平锁的unlock方法

lock.unlock();

unlock里面是这样的:

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

sync是什么??? 是这个

abstract static class Sync extends AbstractQueuedSynchronizer

可以看出来其实调用的就是AbstractQueuedSynchronizer(AQS) 中的 release 方法. 1. 尝试tryRelease操作, 主要是去除锁的独占线程，然后将状态减一，这里减一主要是考虑到可重入锁可能自身会多次占用锁，只有当状态变成0，才表示完全释放了锁.
2. 如果c==0, 则将CHL队列的头节点的状态设置为0, tryRelease成功.
3. 判断下一个节点, 如果是非取消状态, 调用unparkSuccessor唤醒下一个节点
来看看具体实现:

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

ReentrantLock实现的tryRelease方法:

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

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;//获取到head节点的状态
    if (ws < 0)
        //设置head节点状态=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;
        //从CLH队列尾部开始遍历,找到head的下一个节点为止
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        //进行唤醒操作
        LockSupport.unpark(s.thread);
}