整理部分代码

Author: JavaScalaDeveloper

.idea/.gitignore

@@ -5,87 +5,88 @@ ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程
 
 # 2. 重入性的实现原理 #
 
-要想支持重入性，就要解决两个问题：**1. 在线程获取锁的时候，如果已经获取锁的线程是当前线程的话则直接再次获取成功；2. 由于锁会被获取n次，那么只有锁在被释放同样的n次之后，该锁才算是完全释放成功。**通过[这篇文章](https://juejin.im/post/5aeb07ab6fb9a07ac36350c8)，我们知道，同步组件主要是通过重写AQS的几个protected方法来表达自己的同步语义。针对第一个问题，我们来看看ReentrantLock是怎样实现的，以非公平锁为例，判断当前线程能否获得锁为例，核心方法为nonfairTryAcquire：
-
-
-	final boolean nonfairTryAcquire(int acquires) {
-	    final Thread current = Thread.currentThread();
-	    int c = getState();
-	    //1. 如果该锁未被任何线程占有，该锁能被当前线程获取
-		if (c == 0) {
-	        if (compareAndSetState(0, acquires)) {
-	            setExclusiveOwnerThread(current);
-	            return true;
-	        }
-	    }
-		//2.若被占有，检查占有线程是否是当前线程
-	    else if (current == getExclusiveOwnerThread()) {
-			// 3. 再次获取，计数加一
-	        int nextc = c + acquires;
-	        if (nextc < 0) // overflow
-	            throw new Error("Maximum lock count exceeded");
-	        setState(nextc);
-	        return true;
-	    }
-	    return false;
-	}
-
+要想支持重入性，就要解决两个问题：**1. 在线程获取锁的时候，如果已经获取锁的线程是当前线程的话则直接再次获取成功；2. 由于锁会被获取n次，那么只有锁在被释放同样的n次之后，该锁才算是完全释放成功。**
+通过[这篇文章](https://juejin.im/post/5aeb07ab6fb9a07ac36350c8)，我们知道，同步组件主要是通过重写AQS的几个protected方法来表达自己的同步语义。针对第一个问题，我们来看看ReentrantLock是怎样实现的，以非公平锁为例，判断当前线程能否获得锁为例，核心方法为nonfairTryAcquire：
+
+```java
+final boolean nonfairTryAcquire(int acquires) {
+    final Thread current = Thread.currentThread();
+    int c = getState();
+    //1. 如果该锁未被任何线程占有，该锁能被当前线程获取
+    if (c == 0) {
+        if (compareAndSetState(0, acquires)) {
+            setExclusiveOwnerThread(current);
+            return true;
+        }
+    }
+    //2.若被占有，检查占有线程是否是当前线程
+    else if (current == getExclusiveOwnerThread()) {
+        // 3. 再次获取，计数加一
+        int nextc = c + acquires;
+        if (nextc < 0) // overflow
+            throw new Error("Maximum lock count exceeded");
+        setState(nextc);
+        return true;
+    }
+    return false;
+}
+```
 这段代码的逻辑也很简单，具体请看注释。为了支持重入性，在第二步增加了处理逻辑，如果该锁已经被线程所占有了，会继续检查占有线程是否为当前线程，如果是的话，同步状态加1返回true，表示可以再次获取成功。每次重新获取都会对同步状态进行加一的操作，那么释放的时候处理思路是怎样的了？（依然还是以非公平锁为例）核心方法为tryRelease：
-
-	protected final boolean tryRelease(int releases) {
-		//1. 同步状态减1
-	    int c = getState() - releases;
-	    if (Thread.currentThread() != getExclusiveOwnerThread())
-	        throw new IllegalMonitorStateException();
-	    boolean free = false;
-	    if (c == 0) {
-			//2. 只有当同步状态为0时，锁成功被释放，返回true
-	        free = true;
-	        setExclusiveOwnerThread(null);
-	    }
-		// 3. 锁未被完全释放，返回false
-	    setState(c);
-	    return free;
-	}
-
+```java
+protected final boolean tryRelease(int releases) {
+    //1. 同步状态减1
+    int c = getState() - releases;
+    if (Thread.currentThread() != getExclusiveOwnerThread())
+        throw new IllegalMonitorStateException();
+    boolean free = false;
+    if (c == 0) {
+        //2. 只有当同步状态为0时，锁成功被释放，返回true
+        free = true;
+        setExclusiveOwnerThread(null);
+    }
+    // 3. 锁未被完全释放，返回false
+    setState(c);
+    return free;
+}
+```
 代码的逻辑请看注释，需要注意的是，重入锁的释放必须得等到同步状态为0时锁才算成功释放，否则锁仍未释放。如果锁被获取n次，释放了n-1次，该锁未完全释放返回false，只有被释放n次才算成功释放，返回true。到现在我们可以理清ReentrantLock重入性的实现了，也就是理解了同步语义的第一条。
 
 # 3. 公平锁与公平锁 #
 ReentrantLock支持两种锁：**公平锁**和**非公平锁**。**何谓公平性，是针对获取锁而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求上的绝对时间顺序，满足FIFO**。ReentrantLock的构造方法无参时是构造非公平锁，源码为：
-
-	public ReentrantLock() {
-	    sync = new NonfairSync();
-	}
-
+```java
+public ReentrantLock() {
+    sync = new NonfairSync();
+}
+```
 另外还提供了另外一种方式，可传入一个boolean值，true时为公平锁，false时为非公平锁，源码为：
-
-	public ReentrantLock(boolean fair) {
-	    sync = fair ? new FairSync() : new NonfairSync();
-	}
-
+```java
+public ReentrantLock(boolean fair) {
+    sync = fair ? new FairSync() : new NonfairSync();
+}
+```
 在上面非公平锁获取时（nonfairTryAcquire方法）只是简单的获取了一下当前状态做了一些逻辑处理，并没有考虑到当前同步队列中线程等待的情况。我们来看看公平锁的处理逻辑是怎样的，核心方法为：
-
-	protected final boolean tryAcquire(int acquires) {
-	    final Thread current = Thread.currentThread();
-	    int c = getState();
-	    if (c == 0) {
-	        if (!hasQueuedPredecessors() &&
-	            compareAndSetState(0, acquires)) {
-	            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;
-	  }
-	}
-
+```java
+protected final boolean tryAcquire(int acquires) {
+    final Thread current = Thread.currentThread();
+    int c = getState();
+    if (c == 0) {
+        if (!hasQueuedPredecessors() &&
+            compareAndSetState(0, acquires)) {
+            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;
+  }
+}
+```
 这段代码的逻辑与nonfairTryAcquire基本上一直，唯一的不同在于增加了hasQueuedPredecessors的逻辑判断，方法名就可知道该方法用来判断当前节点在同步队列中是否有前驱节点的判断，如果有前驱节点说明有线程比当前线程更早的请求资源，根据公平性，当前线程请求资源失败。如果当前节点没有前驱节点的话，再才有做后面的逻辑判断的必要性。**公平锁每次都是从同步队列中的第一个节点获取到锁，而非公平性锁则不一定，有可能刚释放锁的线程能再次获取到锁**。
 
 > **公平锁  VS  非公平锁**