重入锁

crossoverJie · crossoverJie · commit dd638eddd871 · 2018-01-25T17:17:26.000+08:00
diff --git a/MD/ReentrantLock.md b/MD/ReentrantLock.md
@@ -224,5 +224,75 @@ ReentrantLock 分为**公平锁**和**非公平锁**，可以通过构造方法
         }
 ```
 
+还要一个重要的区别是在尝试获取锁时`tryAcquire(arg)`，非公平锁是不需要判断队列中是否还有其他线程，也是直接尝试获取锁：
+
+```java
+        final boolean nonfairTryAcquire(int acquires) {
+            final Thread current = Thread.currentThread();
+            int c = getState();
+            if (c == 0) {
+                //没有 !hasQueuedPredecessors() 判断
+                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;
+        }
+```
+
+## 释放锁
+
+公平锁和非公平锁的释放流程都是一样的：
+
+```java
+    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;
+            if (Thread.currentThread() != getExclusiveOwnerThread())
+                throw new IllegalMonitorStateException();
+            boolean free = false;
+            if (c == 0) {
+                free = true;
+                setExclusiveOwnerThread(null);
+            }
+            setState(c);
+            return free;
+        }        
+```
+
+首先会判断当前线程是否为获得锁的线程，由于是重入锁所以需要将 `state` 减到 0 才认为完全释放锁。
+
+释放之后需要调用 `unparkSuccessor(h)` 来唤醒被挂起的线程。
+
+
+## 总结
+
+由于公平锁需要关心队列的情况，得按照队列里的先后顺序来获取锁(会造成大量的线程上下文切换)，而非公平锁则没有这个逻辑。
+
+所以也就能解释非公平锁的效率会被公平锁更高。
+
+
 
 
