2. 程式人生 > >Java ReentranLock同步鎖和Condition條件的使用

Java ReentranLock同步鎖和Condition條件的使用

阿新 • • 發佈：2019-01-27

java.util.concurrent.lock 中的 Lock 框架是鎖定的一個抽象，它允許把鎖定的實現作為 Java 類，而不是作為語言的特性來實現。這就為 Lock 的多種實現留下了空間，各種實現可能有不同的排程演算法、效能特性或者鎖定語義。 ReentrantLock 類實現了 Lock ，它擁有與 synchronized 相同的併發性和記憶體語義，但是添加了類似鎖投票、定時鎖等候和可中斷鎖等候的一些特性。此外，它還提供了在激烈爭用情況下更佳的效能。（換句話說，當許多執行緒都想訪問共享資源時，JVM 可以花更少的時候來排程執行緒，把更多時間用在執行執行緒上。）

ReentranLock與synchronized比較

相同：

  • ReentrantLock提供了synchronized類似的功能和記憶體語義。

不同：

  • ReentrantLock功能性方面更全面，比如時間鎖等候，可中斷鎖等候，鎖投票等，因此更有擴充套件性。在多個條件變數和高度競爭鎖的地方，用ReentrantLock更合適，ReentrantLock還提供了Condition，對執行緒的等待和喚醒等操作更加靈活，一個ReentrantLock可以有多個Condition例項，所以更有擴充套件性。

  • ReentrantLock 的效能比synchronized會好點。

  • ReentrantLock提供了可輪詢的鎖請求，他可以嘗試的去取得鎖，如果取得成功則繼續處理，取得不成功，可以等下次執行的時候處理，所以不容易產生死鎖，而synchronized則一旦進入鎖請求要麼成功，要麼一直阻塞，所以更容易產生死鎖。

ReentranLock的使用

實現可輪詢的鎖請求

在內部鎖中，死鎖是致命的——唯一的恢復方法是重新啟動程式，唯一的預防方法是在構建程式時不要出錯。而可輪詢的鎖獲取模式具有更完善的錯誤恢復機制，可以規避死鎖的發生。

如果你不能獲得所有需要的鎖，那麼使用可輪詢的獲取方式使你能夠重新拿到控制權，它會釋放你已經獲得的這些鎖，然後再重新嘗試。可輪詢的鎖獲取模式，由tryLock()方法實現。此方法僅在呼叫時鎖為空閒狀態才獲取該鎖。如果鎖可用，則獲取鎖，並立即返回值true。如果鎖不可用，則此方法將立即返回值false。此方法的典型使用語句如下： 

Lock lock = ...; 
// 嘗試獲取鎖請求,獲取不到鎖時也不會產生死鎖
 

if (lock.tryLock()) { 
    try { 
    // manipulate protected state 
    } finally { 
        lock.unlock(); 
    } 
} else { 
    // perform alternative actions 
}

實現可定時的鎖請求

當使用內部鎖時，一旦開始請求，鎖就不能停止了，所以內部鎖給實現具有時限的活動帶來了風險。為了解決這一問題，可以使用定時鎖。當具有時限的活動呼叫了阻塞方法，定時鎖能夠在時間預算內設定相應的超時。如果活動在期待的時間內沒能獲得結果，定時鎖能使程式提前返回。可定時的鎖獲取模式，由tryLock(long, TimeUnit)方法實現。

實現可中斷的鎖獲取請求

可中斷的鎖獲取操作允許在可取消的活動中使用。lockInterruptibly()方法能夠使你獲得鎖的時候響應中斷。

ReentranLock需要注意的地方

  • lock 必須在 finally 塊中釋放。否則，如果受保護的程式碼將丟擲異常，鎖就有可能永遠得不到釋放！這一點區別看起來可能沒什麼，但是實際上，它極為重要。忘記在 finally 塊中釋放鎖，可能會在程式中留下一個定時炸彈，當有一天炸彈爆炸時，您要花費很大力氣才有找到源頭在哪。而使用同步，JVM 將確保鎖會獲得自動釋放

  • 當 JVM 用 synchronized 管理鎖定請求和釋放時，JVM 在生成執行緒轉儲時能夠包括鎖定資訊。這些對除錯非常有價值，因為它們能標識死鎖或者其他異常行為的來源。 Lock 類只是普通的類，JVM 不知道具體哪個執行緒擁有 Lock 物件。

Condition條件的使用

條件變數很大一個程度上是為了解決Object.wait/notify/notifyAll難以使用的問題。

Condition（也稱為條件佇列 或條件變數）為執行緒提供了一個含義，以便在某個狀態條件現在可能為 true 的另一個執行緒通知它之前，一直掛起該執行緒（即讓其“等待”）。

因為訪問此共享狀態資訊發生在不同的執行緒中，所以它必須受保護，因此要將某種形式的鎖與該條件相關聯。等待提供一個條件的主要屬性是：以原子方式 釋放相關的鎖，並掛起當前執行緒，就像 Object.wait 做的那樣。

上述API說明表明條件變數需要與鎖繫結，而且多個Condition需要繫結到同一鎖上。前面的Lock中提到，獲取一個條件變數的方法是Lock.newCondition()。

void await() throws InterruptedException;

void awaitUninterruptibly();

long awaitNanos(long nanosTimeout) throws InterruptedException;

boolean await(long time, TimeUnit unit) throws InterruptedException;

boolean awaitUntil(Date deadline) throws InterruptedException;

void signal();

void signalAll();

以上是Condition介面定義的方法，await()對應於Object.wait，signal對應於Object.notify，signalAll對應於Object.notifyAll。特別說明的是Condition的介面改變名稱就是為了避免與Object中的wait/notify/notifyAll的語義和使用上混淆，因為Condition同樣有wait/notify/notifyAll方法。

每一個Lock可以有任意資料的Condition物件，Condition是與Lock繫結的，所以就有Lock的公平性特性：如果是公平鎖，執行緒為按照FIFO的順序從Condition.await中釋放，如果是非公平鎖，那麼後續的鎖競爭就不保證FIFO順序了。

使用Condition和Lock實現阻塞佇列

public class BlockingQueue<T> {

    private T[] mItems;

    // 同步鎖
    private final Lock mLock = new ReentrantLock();
    // 佇列滿時的條件
    private Condition mNotFull = mLock.newCondition();
    // 佇列為空時條件
    private Condition mNotEmpty = mLock.newCondition();

    private int mCount;
    private int mHeadIdx;
    private int mTailIdx;

    private static final int DEFAULT_QUEUE_SIZE = 10;

    public BlockingQueue() {
        this(DEFAULT_QUEUE_SIZE);
    }

    public BlockingQueue(int size) {
        mItems = (T[]) new Object[size];
    }

    // 放入元素
    public void put(T item) throws InterruptedException {
        // 獲取讀寫鎖
        mLock.lock();
        try {
            // 此處會進行阻塞,直到有元素取出
            while (mCount == getCapacity()) {
                // 掛起,並釋放鎖,條件滿足時,重新獲取鎖
                mNotFull.await();
            }
            mItems[mTailIdx] = item;
            // 填滿元素
            if (++mTailIdx == getCapacity()) {
                mTailIdx = 0;
            }
            ++mCount;
            // 對阻塞住的take()進行喚醒
            mNotEmpty.signalAll();
        } finally {
            mLock.unlock();
        }
    }

    // 取出元素
    public T take() throws InterruptedException {
        mLock.lock();
        try {
            while (mCount == 0) {
                 // 掛起,並釋放鎖,條件滿足時,重新獲取鎖
                mNotEmpty.await();
            }
            T item = mItems[mHeadIdx];
            mItems[mHeadIdx] = null; // for GC
            if (++mHeadIdx == getCapacity()) {
                mHeadIdx = 0;
            }
            --mCount;
            mNotEmpty.signalAll();
            return item;
        } finally {
            mLock.unlock();
        }
    }

    public int getCapacity() {
        return mItems.length;
    }

}

測試

public class Main {

    private static BlockingQueue<String> sQueue;

    public static void main(String[] args) {
        sQueue = new BlockingQueue<>();
        new Thread(() -> {
            try {
                // 阻塞5秒
                Thread.sleep(5000);
                sQueue.put("Hello");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 從阻塞佇列中取值
        try {
            String item = sQueue.take();
            System.out.println(item);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

await() 操作

上一節中說過多次ReentrantLock是獨佔鎖，一個執行緒拿到鎖後如果不釋放，那麼另外一個執行緒肯定是拿不到鎖，所以在lock.lock()和lock.unlock()之間可能有一次釋放鎖的操作（同樣也必然還有一次獲取鎖的操作）。

我們再回頭看程式碼，不管take()還是put()，在進入lock.lock()後唯一可能釋放鎖的操作就是await()了。也就是說await()操作實際上就是釋放鎖，然後掛起執行緒，一旦條件滿足就被喚醒，再次獲取鎖！


public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    Node node = addConditionWaiter();
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

上面是await()的程式碼片段。上一節中說過,AQS在獲取鎖的時候需要有一個CHL的FIFO佇列，所以對於一個Condition.await()而言，如果釋放了鎖，要想再一次獲取鎖那麼就需要進入佇列，等待被通知獲取鎖。完整的await()操作是安裝如下步驟進行的：

  1. 將當前執行緒加入Condition鎖佇列。特別說明的是，這裡不同於AQS的佇列，這裡進入的是Condition的FIFO佇列。後面會具體談到此結構。進行2。

  2. 釋放鎖。這裡可以看到將鎖釋放了，否則別的執行緒就無法拿到鎖而發生死鎖。進行3。

  3. 自旋(while)掛起，直到被喚醒或者超時或者CACELLED等。進行4。
    獲取鎖(acquireQueued)。並將自己從Condition的FIFO佇列中釋放，表明自己不再需要鎖（我已經拿到鎖了）。

這裡再回頭介紹Condition的資料結構。我們知道一個Condition可以在多個地方被await*()，那麼就需要一個FIFO的結構將這些Condition串聯起來，然後根據需要喚醒一個或者多個（通常是所有）。所以在Condition內部就需要一個FIFO的佇列。

signal/signalAll 操作

await()清楚了，現在再來看signal/signalAll就容易多了。按照signal/signalAll的需求，就是要將Condition.await()中FIFO佇列中第一個Node喚醒（或者全部Node）喚醒。儘管所有Node可能都被喚醒，但是要知道的是仍然只有一個執行緒能夠拿到鎖，其它沒有拿到鎖的執行緒仍然需要自旋等待，就上上面提到的第4步(acquireQueued)。


private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}

private void doSignalAll(Node first) {
    lastWaiter = firstWaiter  = null;
    do {
        Node next = first.nextWaiter;
        first.nextWaiter = null;
        transferForSignal(first);
        first = next;
    } while (first != null);
}

上面的程式碼很容易看出來，signal就是喚醒Condition佇列中的第一個非CANCELLED節點執行緒，而signalAll就是喚醒所有非CANCELLED節點執行緒。當然了遇到CANCELLED執行緒就需要將其從FIFO佇列中剔除。

相關推薦

Java ReentranLock同步鎖和Condition條件的使用

java.util.concurrent.lock 中的 Lock 框架是鎖定的一個抽象，它允許把鎖定的實現作為 Java 類，而不是作為語言的特性來實現。這就為 Lock 的多種實現留下了空間，各種實現可能有不同的排程演算法、效能特性或者鎖定語義。 Re

Java併發包之Lock鎖和Condition條件

一、Synchronized synchronized是Java的一個關鍵字,也就是Java語言內建的特性,如果一個程式碼塊被synchronized修飾了,當一個執行緒獲取了對應的鎖,執行程式碼塊時,其他執行緒便只能一直等待,等待獲取鎖的執行緒釋放鎖,而獲取

Lock鎖和Condition條件

淺談Synchronized:　　synchronized是Java的一個關鍵字,也就是Java語言內建的特性,如果一個程式碼塊被synchronized修飾了,當一個執行緒獲取了對應的鎖,執行程式碼塊時,其他執行緒便只能一直等待,等待獲取鎖的執行緒釋放鎖,而獲取鎖的執行緒釋

java的同步方法和同步程式碼塊，物件鎖，類鎖區別

/** * @author admin * @date 2018/1/12 10:33 * 作用在同一個例項物件上討論 * Synchronized同步方法和同步程式碼塊 * 1、synchronized和synchronized（this）二者沒區別，都作用在this物件鎖上面，所以會同步 *

多線程編程-- part 5.2 JUC鎖之Condition條件

兩個 test extend 釋放 get timeout tin rac main 1.Condition介紹 　　Condition的作用是對鎖進行更精確的控制。Condition中的await()方法相當於Object的wait()方法

python 學習第二十四天（同步鎖和遞迴鎖）

同步鎖 給一段程式碼加了同步鎖之後，在這段程式碼執行時只能有一個執行緒執行。 import time import threading def addNum(): global num #在每個執行緒中都獲取這個全域性變數 #num-=1

執行緒同步鎖和非同步鎖的幾種方式

同步鎖：當在一個java虛擬機器多個執行緒操作一個變數的時候就會出現執行緒安全問題，這個時候就會用到同步鎖。 同步鎖的解決方式： 先看下一個執行緒異常的售票 public class ThreadSafe { public static void main(String[] arg

lock 和condition條件變數的使用

注意點：1.作為物件鎖，寫在Account裡面和外面不一樣，寫在裡面是該類方法只會公用該類物件的鎖，寫在外面表示所有物件都公用那一個鎖，不同使用者公用一個鎖，顯然是不對的。所以寫在裡面表示每個使用者的取錢和存錢共享鎖，和其它的使用者物件沒有關係，因為公用的鎖不一樣。 2. 對於lock 鎖一定注

【Java併發】Lock 和 Condition

Lock 和 Condition Lock 介面 ReentrantLock ReentrantReadWriteLock Condition 參考 Lock 介面 在Lock接口出現之前，Java程式是靠synchro

從零開始構建一個Reactor模式的網路庫（一） 執行緒同步Mutex和Condition

最近在學習陳碩大神的muduo庫，感覺寫的很專業，以及有一些比較“高階”的技巧和設計方式，自己寫會比較困難。 於是打算自己寫一個簡化版本的Reactor模式網路庫，就取名叫mini吧，同樣只基於Linux平臺，不使用boost庫，去掉一些比較複雜的部分，只實現比較基本的功能。 寫作的過程中，參考了http

#Java中活鎖和死鎖有什麼區別？如何避免死鎖？

Java中活鎖和死鎖是指什麼，你知道他們之間的區別嗎，下面我們可以來討論一下： 如果有想要學習java的小夥伴，可來我們的java學習扣裙哦：72340,3928裡面贈送java系列教學視訊和資料!小編也是從事了6年java開發的全棧工程師，歡迎初學者和想要進階

Java中物件鎖和類鎖

Java中的鎖：（簡要描述） 多執行緒的執行緒同步機制實際上是靠鎖的概念來控制的。 在Java程式執行時環境中，JVM需要對兩類執行緒共享的資料進行協調： 1）儲存在堆中的例項變數 2）儲存在方法區中的類變數 這兩類資料是被所有執行緒共享的。 （程式不需要協調儲存在Jav

原始碼分析AQS獨佔鎖、共享鎖和Condition的實現

AbstractQueuedSynchronizer是java.util.concurrent包下非常重要和基礎的類，concurrent包下提供了一系列的同步操作需要的工具，包括了ReentrantLock、ReentrantReadWriteLock、Thr

Linux C++ 執行緒同步鎖和wait()/broadcast()功能(二)

在第一篇中，我們講解了linux下鎖的概念: https://blog.csdn.net/zhangkai19890929/article/details/85107046 這一篇我們主要講解wait()和broadcast的 知識: 首先我們需要介紹的是: pthread_co

Linux C++ 執行緒同步鎖和wait()/broadcast()功能(一)

首先說下linux下的執行緒同步鎖的實現: 同步鎖脫離不開:pthread_mutex_t,mutex是互斥的意思，因此linux下的鎖是通過互斥訊號來實現的. pthread_mutex_t:代表一個互斥鎖，首先我們需要初始化這個互斥鎖. 第一步我們需要初始化互斥鎖: pt

透徹理解 Java synchronized 物件鎖和類鎖的區別

synchronized 加到 static 方法前面是給class 加鎖，即類鎖；而synchronized 加到非靜態方法前面是給物件上鎖。這兩者的區別我用程式碼來演示下： 物件鎖和類鎖是不同的鎖，所以多個執行緒同時執行這2個不同鎖的方法時，是非同步的。

Java面試--樂觀鎖和悲觀鎖

面試題：樂觀鎖和悲觀鎖的區別 一、樂觀鎖 總是認為不會產生併發問題，每次去取資料的時候總認為不會有其他執行緒對資料進行修改，因此不會上鎖，但是在更新時會判斷其他執行緒在這之前有沒有對資料進

Java的類鎖和物件鎖

類鎖和物件鎖不是同1個東西，一個是類的Class(對應的唯一的一個即這類的二進位制位元組碼)物件的鎖，1個是類的例項(！即new出的一個類的物件，一個類會有多個例項物件)的鎖。也就是說：1個執行緒訪

JUC學習之同步鎖和閉鎖

一、同步鎖（Lock）：同步鎖是一個顯示鎖，需要通過 lock() 上鎖，通過 unlock() 釋放鎖 public class Test { public static void main(String[] args) throws Exec

Java併發程式設計-Lock和condition的原理及AQS的運用

AQS的全稱為（AbstractQueuedSynchronizer），這個類也是在java.util.concurrent.locks下面。這個類似乎很不容易看懂，因為它僅僅是提供了一系列公共的方法，讓子類來呼叫。那麼要理解意思，就得從子類下手，反過來看才容易看