Java多線(xiàn)程之深入理解ReentrantLock

目錄

前言

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

一、可重入鎖

所謂可重入鎖，即一個(gè)線(xiàn)程已經(jīng)獲得了某個(gè)鎖，當這個(gè)線(xiàn)程要再次獲取這個(gè)鎖時(shí)，依然可以獲取成功，不會(huì )發(fā)生死鎖的情況。synchronized就是一個(gè)可重入鎖，除此之外，JDK提供的ReentrantLock也是一種可重入鎖。

二、ReentrantLock

2.1 ReentrantLock的簡(jiǎn)單使用

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的一個(gè)簡(jiǎn)單使用案列，進(jìn)入同步代碼塊之前，需要調用lock()方法進(jìn)行加鎖，執行完同步代碼塊之后，為了防止異常發(fā)生時(shí)造成死鎖，需要在finally塊中調用unlock()方法進(jìn)行解鎖。

2.2 ReentrantLock UML圖

2.3 lock()方法調用鏈

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

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

在這個(gè)方法中，先嘗試通過(guò)CAS操作進(jìn)行加鎖。如果加鎖失敗，會(huì )調用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();
}

在A(yíng)QS的acquire方法中，先嘗試調用tryAcquire方法進(jìn)行加鎖，如果失敗，會(huì )調用acquireQueued進(jìn)入等待隊列當中。acquireQueued方法將會(huì )在第三章中講解，先來(lái)看tryAcquire方法的內容。AQS的tryAcquire方法是一個(gè)模板方法，其具體實(shí)現在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;
}

在這個(gè)方法中，先獲取state判斷其是否為0。如果為0表示沒(méi)有其他線(xiàn)程占用鎖，會(huì )嘗試通過(guò)CAS操作將state設為1進(jìn)行加鎖；如果state不為0，表示某個(gè)線(xiàn)程已經(jīng)占用了鎖，判斷占用鎖的線(xiàn)程是否為當前線(xiàn)程，如果是，則將state進(jìn)行加1的操作，這就是ReentrantLock可重入的實(shí)現原理。

三、AQS

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

3.1 state

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

state是AQS中最核心的成員變量。這是一個(gè)volatile變量，當其為0時(shí)，表示沒(méi)有任何線(xiàn)程占用鎖。線(xiàn)程通過(guò)CAS將state從0置為1進(jìn)行加鎖，當線(xiàn)程持有鎖的情況下，再次進(jìn)行加鎖，會(huì )將state加1，即重入。

3.2 exclusiveOwnerThread

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

exclusiveOwnerThread是AQS的父類(lèi)AbstractOwnableSynchronizer中的成員變量，其作用是實(shí)現可重入機制時(shí)，用于判斷持有鎖的線(xiàn)程是否為當前線(xiàn)程。

3.3 AQS等待隊列

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

/**
 * 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;
        // 通過(guò)CAS操作將自身追加到鏈表尾部
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

當線(xiàn)程嘗試加鎖失敗時(shí)，通過(guò)CAS操作將自身追加到鏈表尾部。入隊之后，會(huì )調用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);
        }
    }

在這個(gè)方法中，會(huì )判斷其前置節點(diǎn)是否為頭節點(diǎn)，如果是，則嘗試進(jìn)行加鎖。如果加鎖失敗，則調用LockSupport.park方法進(jìn)入阻塞狀態(tài)，等待其前置節點(diǎn)釋放鎖之后將其喚醒。

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();
}

這些方法在A(yíng)QS中只拋出了UnsupportedOperationException異常，所以需要子類(lèi)去實(shí)現它們。之所以沒(méi)有將這些方法設計成為抽象方法，是因為AQS的子類(lèi)可能只需要實(shí)現其中的某些方法即可實(shí)現其功能。

總結

不同版本的JDK，AQS的實(shí)現可能會(huì )有細微的差異，但其核心思想是不會(huì )變的，即線(xiàn)程加鎖失敗后，通過(guò)CAS進(jìn)行入隊的操作，并通過(guò)CAS的方法設置state來(lái)獲得鎖。

到此這篇關(guān)于Java多線(xiàn)程之深入理解ReentrantLock的文章就介紹到這了,更多相關(guān)Java ReentrantLock總結內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！