前言

保證線程安全的方式有很多，比如CAS操作、synchronized、原子類、volatile保證可見性和ReentrantLock等，這篇文章我們主要探討ReentrantLock的相關內容。本文基于JDK1.8講述ReentrantLock.

一、可重入鎖

所謂可重入鎖，即一個線程已經獲得了某個鎖，當這個線程要再次獲取這個鎖時，依然可以獲取成功，不會發生死鎖的情況。synchronized就是一個可重入鎖，除此之外，JDK提供的ReentrantLock也是一種可重入鎖。

二、ReentrantLock2.1 ReentrantLock的簡單使用

public class TestReentrantLock {private static int i = 0;public static void main(String[] args) {ReentrantLock lock = new ReentrantLock();try { lock.lock(); i++;} finally { lock.unlock();}System.out.println(i);}}

上面是ReentrantLock的一個簡單使用案列，進入同步代碼塊之前，需要調用lock()方法進行加鎖，執行完同步代碼塊之后，為了防止異常發生時造成死鎖，需要在finally塊中調用unlock()方法進行解鎖。

2.2 ReentrantLock UML圖

2.3 lock()方法調用鏈

上圖描述了ReentrantLock.lock()加鎖的方法調用過程。在ReentrantLock中有一個成員變量private final Sync sync，Sync是AQS的一個子類。ReentrantLock的lock()方法中，調用了sync的lock()方法，這個方法為抽象方法，具體調用的是NonfairSync中實現的lock()方法：

/** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */final void lock() { if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread()); elseacquire(1);}

在這個方法中，先嘗試通過CAS操作進行加鎖。如果加鎖失敗，會調用AQS的acquire()方法：

/** * Acquires in exclusive mode, ignoring interrupts. Implemented * by invoking at least once {@link #tryAcquire}, * returning on success. Otherwise the thread is queued, possibly * repeatedly blocking and unblocking, invoking {@link * #tryAcquire} until success. This method can be used * to implement method {@link Lock#lock}. * * @param arg the acquire argument. This value is conveyed to *{@link #tryAcquire} but is otherwise uninterpreted and *can represent anything you like. */public final void acquire(int arg) { if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

在AQS的acquire方法中，先嘗試調用tryAcquire方法進行加鎖，如果失敗，會調用acquireQueued進入等待隊列當中。acquireQueued方法將會在第三章中講解，先來看tryAcquire方法的內容。AQS的tryAcquire方法是一個模板方法，其具體實現在NonfairSync的tryAcquire方法中，里面僅僅是調用了nonfairTryAcquire方法：

/** * Performs non-fair tryLock. tryAcquire is implemented in * subclasses, but both need nonfair try for trylock method. */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) // overflow throw new Error('Maximum lock count exceeded');setState(nextc);return true; } return false;}

在這個方法中，先獲取state判斷其是否為0。如果為0表示沒有其他線程占用鎖，會嘗試通過CAS操作將state設為1進行加鎖；如果state不為0，表示某個線程已經占用了鎖，判斷占用鎖的線程是否為當前線程，如果是，則將state進行加1的操作，這就是ReentrantLock可重入的實現原理。

三、AQS

AQS即AbstractQueuedSynchronizer。AQS提供了一個基于FIFO隊列，可以用于構建鎖或者其他相關同步裝置的基礎框架。AQS其實是CLH(Craig，Landin，Hagersten)鎖的一個變種，下面來講解AQS的核心思想及其具體實現。

3.1 state

/** * The synchronization state. */ private volatile int state;

state是AQS中最核心的成員變量。這是一個volatile變量，當其為0時，表示沒有任何線程占用鎖。線程通過CAS將state從0置為1進行加鎖，當線程持有鎖的情況下，再次進行加鎖，會將state加1，即重入。

3.2 exclusiveOwnerThread

/** * The current owner of exclusive mode synchronization. */ private transient Thread exclusiveOwnerThread;

exclusiveOwnerThread是AQS的父類AbstractOwnableSynchronizer中的成員變量，其作用是實現可重入機制時，用于判斷持有鎖的線程是否為當前線程。

3.3 AQS等待隊列

除了以上state和exclusiveOwnerThread兩個重要的成員變量以外，AQS還維護了一個等待隊列。當線程嘗試加鎖失敗時，會進入這個等待隊列中，這也是整個AQS中最核心的內容。這個等待隊列是一個雙向鏈表，其節點Node對等待加鎖的線程進行封裝。

/** * Creates and enqueues node for current thread and given mode. * * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared * @return the new node */private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // Try the fast path of enq; backup to full enq on failure Node pred = tail; if (pred != null) {node.prev = pred;// 通過CAS操作將自身追加到鏈表尾部if (compareAndSetTail(pred, node)) { pred.next = node; return node;} } enq(node); return node;}

當線程嘗試加鎖失敗時，通過CAS操作將自身追加到鏈表尾部。入隊之后，會調用acquireQueued在隊列中嘗試加鎖：

/** * Acquires in exclusive uninterruptible mode for thread already in * queue. Used by condition wait methods as well as acquire. * * @param node the node * @param arg the acquire argument * @return {@code true} if interrupted while waiting */ final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try { boolean interrupted = false; for (;;) {final Node p = node.predecessor();if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; return interrupted;}if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; }} finally { if (failed)cancelAcquire(node);} }

在這個方法中，會判斷其前置節點是否為頭節點，如果是，則嘗試進行加鎖。如果加鎖失敗，則調用LockSupport.park方法進入阻塞狀態，等待其前置節點釋放鎖之后將其喚醒。

3.4 AQS中的模板方法設計模式

AQS完美地運用了模板方法設計模式，其中定義了一系列的模板方法。比如以下方法：

// 互斥模式下使用：嘗試獲取鎖protected boolean tryAcquire(int arg) {throw new UnsupportedOperationException();}// 互斥模式下使用：嘗試釋放鎖protected boolean tryRelease(int arg) {throw new UnsupportedOperationException();}// 共享模式下使用：嘗試獲取鎖protected int tryAcquireShared(int arg) {throw new UnsupportedOperationException();}// 共享模式下使用：嘗試釋放鎖protected boolean tryReleaseShared(int arg) {throw new UnsupportedOperationException();}

這些方法在AQS中只拋出了UnsupportedOperationException異常，所以需要子類去實現它們。之所以沒有將這些方法設計成為抽象方法，是因為AQS的子類可能只需要實現其中的某些方法即可實現其功能。

總結

不同版本的JDK，AQS的實現可能會有細微的差異，但其核心思想是不會變的，即線程加鎖失敗后，通過CAS進行入隊的操作，并通過CAS的方法設置state來獲得鎖。

到此這篇關于Java多線程之深入理解ReentrantLock的文章就介紹到這了,更多相關Java ReentrantLock總結內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！