重入锁

crossoverJie · crossoverJie · commit 16372ec0b866 · 2018-01-25T15:19:03.000+08:00
diff --git a/MD/ReentrantLock.md b/MD/ReentrantLock.md
@@ -4,4 +4,90 @@
 
 而 `ReentrantLock` 就是一个普通的类，它是基于 `AQS(AbstractQueuedSynchronizer)`来实现的。
 
-> `AQS` 是 `Java` 并发包里实现锁、同步的一个基础框架。
+> `AQS` 是 `Java` 并发包里实现锁、同步的一个基础框架。
+
+
+## 锁类型
+
+ReentrantLock 分为**公平锁**和**非公平锁**，可以通过构造方法来指定具体类型：
+
+```java
+    //默认非公平锁
+    public ReentrantLock() {
+        sync = new NonfairSync();
+    }
+    
+    //公平锁
+    public ReentrantLock(boolean fair) {
+        sync = fair ? new FairSync() : new NonfairSync();
+    }
+```
+
+默认一般使用**非公平锁**，它的效率和吞吐量都比公平锁高的多(后面会分析具体原因)。
+
+## 获取锁
+
+通常的使用方式如下:
+
+```java
+    private ReentrantLock lock = new ReentrantLock();
+    public void run() {
+        lock.lock();
+        try {
+            //do bussiness
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
+```
+
+### 公平锁获取锁
+首先看下获取锁的过程：
+
+```java
+    public void lock() {
+        sync.lock();
+    }
+```
+
+可以看到是使用 `sync`的方法，而这个方法是一个抽象方法，具体是由其子类(`FairSync`)来实现的，以下是公平锁的实现:
+
+```java
+        final void lock() {
+            acquire(1);
+        }
+        
+        //AbstractQueuedSynchronizer 中的 acquire()
+        public final void acquire(int arg) {
+        if (!tryAcquire(arg) &&
+            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
+            selfInterrupt();
+    }
+```
+
+第一步是尝试获取锁(`tryAcquire(arg)`),这个也是由其子类实现：
+
+```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;
+        }
+    }
+```
