ReentrantLock 源码分析

ReentrantLock 加解锁源代码分析

ReentrantLock是java同步JUC的一个重要功能，下面我们就从源代码入手，详细分析它的加解锁过程。

ReentrantLock.lock() 加锁

public void lock() {// 其中sync为 Sync -> AbstractQueuedSynchronizer（为了方便下文简称AQS），说明Sync是基于AQS实现的。// 对于Sync的实现又有NonfairSync和FairSync sync.lock();}

NonfairSync 加锁流程

/** * 执行加锁 * 首先：尝试修改state状态，如果修改成功表示获取锁，将独占线程修改为当前线程 * 其次：如果修改失败，则进入正常的加锁流程 */final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1);}

/** * 以独占的方式获取锁，并且忽略中断。 * */public final void acquire(int arg) { // 如果没有获取成功，则将当前线程添加到队列尾部然后将当前线程中断 if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt();}

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

final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //没有线程持有锁 if (c == 0) { //以CAS的方式去获取锁，如果获得成功，则将独占线程设置为当前线程 if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } //是否可重入 else if (current == getExclusiveOwnerThread()) { // 如果是当前线程持有锁，那么state就是当前线程获取锁的次数，每当获取一次锁，状态计数器加1 int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); // 这里没有并发，直接set 计数器的值 setState(nextc); return true; } return false;}

/*** 根据给出的模式为当前线程创建入队节点* 有独占和共享两种模式，对于ReentrantLock来说，是独占模式*/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插入到队尾 */private Node enq(final Node node) { for (;;) { Node t = tail; // 如果队列为空，新建一个空节点来初始化队列 if (t == null) { // Must initialize if (compareAndSetHead(new Node())) tail = head; } else { // 队列初始化完成后将node插入到队尾 node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } }}

final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; for (;;) { final Node p = node.predecessor(); //判断node是不是第二个节点，如果是，则尝试获取锁，如果获取成功则将node置为首节点，返回false 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); }}

/** * 从方法名上理解，如果锁获取失败了应该阻塞当前线程 */private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; if (ws == Node.SIGNAL) //Node.SIGNAL = -1; /* * 如果为node的前继节点为SIGNAL，那么当前继节点释放锁后，会唤醒后继（当前）节点，那么node可以安全阻塞 */ return true; if (ws > 0) { // 前继节点取消 /* * 前继节点被取消，则跳过前继节点重试 */ do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { /* * 否则把前继节点的状态设置SIGNAL，然后下一次进来是直接返回true。利用LockSupport.park()方法将线程阻塞然后再中断。 */ compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false;}

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

FairSync 公平锁

公平锁的加锁流程就是非公平锁开始获取锁失败的，进入正常流程的环节，具体加锁流程参考非公平锁的部分。

final void lock() { acquire(1);}

ReentrantLock.unlock() 解锁

通过上面的加锁流程，我们可以知道，无论是公平锁还是非公平锁，它们获取锁的过程其实就是当前线程将state的状态由0变为1（同一个线程重入就是将state状态累加），如果当前线程没有获取锁就将给当前线程创建一个node节点添加到等待队列的末尾，并且将当前线程阻塞，直到前一个线程释放锁并且唤醒当前线程的过程。由此推断解锁的过程无非也就是将state状态由1到0（同一线程可重入的时候就是将正整数递减到0），并且唤醒后继线程的过程。以下是源代码分析：

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

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) { int c = getState() - releases; //如果当前线程没有重入，那么这里的getState应该等于1 if (Thread.currentThread() != getExclusiveOwnerThread()) //只有拥有锁的线程才能释放锁 throw new IllegalMonitorStateException(); boolean free = false; //如果没有重入，一次释放 if (c == 0) { free = true; setExclusiveOwnerThread(null); } //如果重入了，那么state递减， setState(c); return free;}

private void unparkSuccessor(Node node) { int ws = node.waitStatus; //如果还有线程在等待锁，那么首节点的waitStatus=-1 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); //唤醒没有被取消的节点的线程}

相比加锁流程，解锁流程还是很easy的。至此，ReentrantLock的加解锁的流程就分析完了，顺便提下，ReentrantLock默认为非公平锁。