重入锁(ReentrantLock)学习
重入锁：也是排他锁：即在同一时刻只允许一个线程进行访问。
一、公平和非公平获取锁的区别
1、公平获取与非公平获取两者对比
公平锁：每次都是从同步队列中的第一个节点获取到锁
非公平性锁：每个线程可以连续多次获取锁
TODO: 缺图
非公平锁缺点：
-
非公平锁，可能使线程“饥饿”，饥饿出现的情况。
-
饥饿的原因：当一个线程请求锁时，只要获取了同步状态即成功获取锁。在这个前提下，刚释放锁的线程再次获取同步状态的几率非常大，使得其他线程只能在同步队列中等待。
2、为什么 ReentrankLock 默认是非公平锁实现？
如果把每次线程获取到锁定义为 1 次切换，公平性锁每次都要进行切换，而非公平性锁可以相比较而言减少线程切换。
TODO：缺图
通过实验对比结论：
在测试中，公平性锁与非公平性锁比较，总耗时是其 94.3 倍，总切换次数是其 103 倍。
可见：
-
公平性锁保证了锁的获取按照 FIFO 原则，而代价是进行了大量的线程切换。
-
非公平性锁虽然造成了线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。
二、非公平锁的获取和释放
以非公平锁的获取和释放为例。
1、tryAcquire(int acquires)
java.util.concurrent.locks.ReentrantLock.NonfairSync#tryAcquire
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;/*** Performs lock. Try immediate barge, backing up to normal* acquire on failure.*/final void lock() {
// 非公平锁的获取：只要 CAS 设置同步状态成功，则表示当前线程获取了锁if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}// 非公平锁的获取protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);}}
上面代码可以看到：非公平锁的获取，只要 CAS 设置同步状态成功，则表示当前线程获取了锁
1.1 nonfairTryAcquire(int acquires)
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) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}
该方法增加了再次获取同步状态的处理逻辑：通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程再次请求，则将同步状态值进行增加并返回 true。表示获取同步状态成功。
成功获取锁的线程再次获取锁，只是增加了同步状态值。
这也就要求 ReentrantLock 在释放同步状态时减少同步状态值。
2、 tryRelease(int releases)
protected final boolean tryRelease(int releases) {
int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {
// 最终释放条件：同步状态是否为 0 free = true;// 将占有线程设置为 nullsetExclusiveOwnerThread(null);}setState(c);return free;}
如果该锁被释放了 n 次，那么前（n-1）次 tryRelease(int releases)方法必须返回 flase，而只有同步状态完全释放了，才能返回 true。可以看到，该方法将同步状态是否为 0 作为最终释放的条件，当同步状态为0 时，将占有线程设置为 null，并返回 true，表示释放成功。
三、公平锁的获取与释放
公平和非公平，是针对锁而言的
如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是 FIFO。
下面有代码中有标记其区别：
1、tryAcquire(int acquires)方法
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;final void lock() {
acquire(1);}/*** Fair version of tryAcquire. Don't grant access unless* recursive call or no waiters or is first.*/protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();int c = getState();if (c == 0) {
// 公平锁的获取与非公平锁区别：hasQueuedPredecessors()// 判断条件多了方法：加入了同步队列中当前节点是否有前驱节点的判断// 如果该方法返回 true，表示有线程比当前线程更早的请求获取锁，// 因此需要等待前驱线程获取锁并释放锁之后才能继续获取锁if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {
// cas 成功。setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}}
2、hasQueuedPredecessors()
公平锁中加入的一个判断条件：加入了同步队列中当前节点是否有前驱节点的判断
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized// before tail and on head.next being accurate if the current// thread is first in queue.Node t = tail; // Read fields in reverse initialization orderNode h = head;Node s;return h != t &&((s = h.next) == null || s.thread != Thread.currentThread());}