一 ReentranctLock

1.1 ReentranctLock

1.ReentrantLock 意思为可重入锁，指的是一个线程能够对一个临界资源重复加锁。ReentrantLock内部实现依赖于AQS。

1.2 ReentranctLock的结构组成

ReentrantLock有三个内部类：
Sync：继承自AQS的同步控制基础。
NonfairSync：Sync的非公平版本实现
FairSync：Sync的公平版本实现
ReentrantLock默认实例化的非公平锁NonfairSync。可以通过传递true，来实例化公平锁FairSync

1.3 ReentranctLock的加锁和解锁流程

1）FairSync加锁过程：
1.调用lock()方法即可加锁。
2.加锁时先tryAcquire(1)尝试获取锁：
2.1 如果获取成功，那么把当前线程设置为工作线程，结束加锁流程
2.2 如果获取失败，那么把当前线程添加到CLH队列的队尾进行等待。
2）FairSync解锁过程：
1.调用unlock()方法即可解锁。注意，该方法一定要放在finally块中进行调用！
2.解锁时调用tryRelease(arg)方法
2.1如果成功，唤醒等待队列中的线程进行工作
2.2如果失败，返回false

3）NonFairSync加锁解锁过程：
1.NonFairSync会在调用lock()时，直接尝试把state设置为1：
1.1如果失败，会调用nonfairTryAcquire()获取锁，而nonfairTryAcquire()在获取锁的时候，也不会顾及CLH队列中是否有线程在等待获取锁，从而实现非公平加锁。
1.2如果成功，直接获取锁，执行业务。
4）解锁过程和FairSync一致。

二 ReentranctLock源码分析

2.1 公平锁

2.1.1 lock方法

1.看到lock()方法其实就是调用Sync的lock()方法，而Sync的Lock有NonFairSync和FairSync两种实现。

2.这边先看FairSync的实现，该方法的参数1，实际上即是state的值，1表示加锁。继续看acquire()方法：

3.acquire()调用了三个方法，分别是：

   tryAcquire()：尝试以独占模式获取锁

   addWaiter()：为当前线程和给定模式创建并排队节点。

    acquireQueued()：以独占不中断模式获取已在队列中的线程

如下图所示：

 3.1 tryAcquire()方法

protected final boolean tryAcquire(int acquires) {// 获取当前线程final Thread current = Thread.currentThread();// 获取state的值int c = getState();// state等于0，即共享资源没有被加锁if (c == 0) {/*先看队列中有没有线程在等待获取锁，如果没有那就设置当前线程就是工作线程如果有就返回false，此处体现了公平锁特性*/if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {// 设置当前线程为独占线程setExclusiveOwnerThread(current);return true;}}// 如果当前工作线程是该线程，那么可以重复获取锁，并将state的值+1，此处体现了ReentrantLock是可重入锁else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;// int有最大值，超过最大值后，state会变成负数，因此加了这个判断if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}// 共享资源被锁定，返回falsereturn false;
}

这个方法的第一个if判断，提现了获取锁是公平的；第二个则体现是ReentrantLock是可重入锁。

看一下hasQueuedPredecessors()方法，

hasQueuedPredecessors():代码逻辑如下：

public final boolean hasQueuedPredecessors() {Node t = tail; Node h = head;Node s;// 头结点不等于尾节点，并且，（头结点的next不为null，或者next的线程不是当前线程）return h != t &&((s = h.next) == null || s.thread != Thread.currentThread());
}

3.2 addWaiter()：

private Node addWaiter(Node mode) {// 把当前线程作为入参创建一个Node节点Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;// 如果队列的尾节点不为null，把node添加到队尾if (pred != null) {node.prev = pred;// cas设置尾节点if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}// 将节点插入队列，如果队列为空则初始化队列 enq(node);return node;
}

addWaiter()，就是把当前线程添加到队列中。 其中的enq()是在快速添加node到队尾失败才会调用，而这个方法也是添加node到队列中。

acquireQueued()：

final boolean acquireQueued(final Node node, int arg) {// 标记是否成功拿到资源boolean failed = true;try {// 标记等待过程中是否中断过boolean interrupted = false;// 开始自旋，要么获取锁，要么中断for (;;) {// 获取当前节点的前节点final Node p = node.predecessor();// 如果前节点是头结点（工作节点）并且tryAcquire()成功if (p == head && tryAcquire(arg)) {// 把node设置为头结点setHead(node);p.next = null; // help GCfailed = false;return interrupted;}// 靠前驱节点判断当前线程是否应该被阻塞if (shouldParkAfterFailedAcquire(p, node) &&// 阻塞当前节点parkAndCheckInterrupt())interrupted = true;}} finally {// 如果执行失败，则把这个节点状态设置为取消状态if (failed)cancelAcquire(node);}
}

这边多了shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()方法。

shouldParkAfterFailedAcquire()：靠前驱节点判断当前线程是否应该被阻塞

// 靠前驱节点判断当前线程是否应该被阻塞
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {// 获取头结点的节点状态int ws = pred.waitStatus;// 说明头结点处于唤醒状态if (ws == Node.SIGNAL)return true;// 通过枚举值我们知道waitStatus>0是取消状态if (ws > 0) {do {// 循环向前查找取消节点，把取消节点从队列中剔除node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {// 设置前任节点等待状态为SIGNALcompareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;
}

parkAndCheckInterrupt()：阻塞当前节点

private final boolean parkAndCheckInterrupt() {// 阻塞当前线程LockSupport.park(this);// 当前线程被唤醒后，返回线程的中断状态，然后重置中断状态return Thread.interrupted();
}

2.1.2 unlock方法

1.在调用lock.unlock()时候，内部调用的是Sync的release()方法，源码：

2.release()： 

public final boolean release(int arg) {// 释放锁if (tryRelease(arg)) {Node h = head;// 如果当前头结点不为null，并且waitStatus不是0（无锁状态）if (h != null && h.waitStatus != 0)// 唤醒下一个线程开展业务unparkSuccessor(h);return true;}return false;
}

release()会调用tryRelease()方法：

• 如果返回tryRelease()false，那么release()直接返回false
• 如果返回true，进行判断后，会唤醒队列中下一个线程进行工作

3.tryRelease()：

protected final boolean tryRelease(int releases) {// 获取state的值，并且减去1（releases等于1）int c = getState() - releases;// 判断当前线程是不是工作线程，如果不是，抛出异常if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();// 共享资源是否空闲的标记boolean free = false;// 如果state为0（空闲）if (c == 0) {// 设置空闲标记为true，并把当前工作线程设置为nullfree = true;setExclusiveOwnerThread(null);}// 设置state等于0setState(c);return free;
}

tryRelease()会释放一次锁，不过ReentrantLock是可重入锁，因此释放一次后，共享资源不一定会处于空闲状态。

4.unparkSuccessor()：

private void unparkSuccessor(Node node) {// 获取头结点waitStatusint ws = node.waitStatus;if (ws < 0)compareAndSetWaitStatus(node, ws, 0);// 获取当前节点的下一个节点Node s = node.next;// 如果下个节点是null或者下个节点被cancelled，就找到队列最开始的非cancelled的节点if (s == null || s.waitStatus > 0) {s = null;// 就从尾部节点开始找，到队首，找到队列第一个waitStatus<0的节点。for (Node t = tail; t != null && t != node; t = t.prev)if (t.waitStatus <= 0)s = t;}// 如果当前节点的下个节点不为空，而且状态<=0，就把当前节点unparkif (s != null)LockSupport.unpark(s.thread);
}

unparkSuccessor()就是唤醒线程进行工作。只有当唤醒下一个线程后，release()方法才会返回true。

2.2 非公平锁

2.2.1 非公平锁

对比FairSync的源码，会发现两者的区别就是在于lock方法：

1.非公平锁： 不公平锁加锁时，会直接尝试设置state的值。

final void lock() {// 第一步直接尝试设置state的值（不公平啊）if (compareAndSetState(0, 1))// 设置成功，设置当前线程为工作线程setExclusiveOwnerThread(Thread.currentThread());else// 设置失败，再去尝试获取锁acquire(1);
}

 2.在看accuire方法：可以看到和FairSync的acquire()方法一样，唯一不同的是tryAcquire()的不同；

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

3.tryAcquire()：tryAcquire()调用的是nonfairTryAcquire(),

4.nonfairTryAcquire():

对比FairSync的tryAcquire()方法和nonfair的TryAcquire()方法，可以看出唯一的区别就是FairSync的tryAcquire()方法多了一个hasQueuedPredecessors()的判断，这个判断是判断CLH队列中有没有线程在等待获取资源。而非公平锁就不管等待队列是否有等待线程，直接去尝试获取资源（不公平）。ReentrantLock加锁和解锁-CSDN博客

final boolean nonfairTryAcquire(int acquires) {// 获取当前线程final Thread current = Thread.currentThread();int c = getState();// 如果共享资源处于空闲状态if (c == 0) {// 尝试设置直接设置state（不管队列中是否有排队的线程直接就插队，不公平啊）if (compareAndSetState(0, acquires)) {// 设置state成功，就把当前线程设置为工作线程setExclusiveOwnerThread(current);return true;}}// 如果当前线程就是工作线程，那么可以重复加锁else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;
}