国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

深入理解Java內存模型(五)——鎖

caige / 712人閱讀

摘要:前情提要深入理解內存模型四鎖的釋放獲取建立的關系鎖是并發編程中最重要的同步機制。鎖內存語義的實現本文將借助的源代碼,來分析鎖內存語義的具體實現機制。請看下篇深入理解內存模型六

前情提要 深入理解Java內存模型(四)—— volatile

鎖的釋放-獲取建立的happens before 關系

鎖是java并發編程中最重要的同步機制。鎖除了讓臨界區互斥執行外,還可以讓釋放鎖的線程向獲取同一個鎖的線程發送消息。下面是鎖釋放-獲取的示例代碼:

class MonitorExample {
    int a = 0;

    public synchronized void writer() {  //1
        a++;                             //2
    }                                    //3

    public synchronized void reader() {  //4
        int i = a;                       //5
        ……
    }                                    //6
}

假設線程A執行writer()方法,隨后線程B執行reader()方法。根據happens
before規則,這個過程包含的happens before 關系可以分為兩類:

根據程序次序規則,1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。

根據監視器鎖規則,3 happens before 4。

根據happens before 的傳遞性,2 happens before 5。

上述happens before 關系的圖形化表現形式如下:

在上圖中,每一個箭頭鏈接的兩個節點,代表了一個happens before 關系。黑色箭頭表示程序順序規則;橙色箭頭表示監視器鎖規則;藍色箭頭表示組合這些規則后提供的happens before保證。

上圖表示在線程A釋放了鎖之后,隨后線程B獲取同一個鎖。在上圖中,2 happens before 5。因此,線程A在釋放鎖之前所有可見的共享變量,在線程B獲取同一個鎖之后,將立刻變得對B線程可見。

鎖釋放和獲取的內存語義

當線程釋放鎖時,JMM會把該線程對應的本地內存中的共享變量刷新到主內存中。以上面的MonitorExample程序為例,A線程釋放鎖后,共享數據的狀態示意圖如下:

當線程獲取鎖時,JMM會把該線程對應的本地內存置為無效。從而使得被監視器保護的臨界區代碼必須要從主內存中去讀取共享變量。下面是鎖獲取的狀態示意圖:

對比鎖釋放-獲取的內存語義與volatile寫-讀的內存語義,可以看出:鎖釋放與volatile寫有相同的內存語義;鎖獲取與volatile讀有相同的內存語義。

下面對鎖釋放和鎖獲取的內存語義做個總結:

線程A釋放一個鎖,實質上是線程A向接下來將要獲取這個鎖的某個線程發出了(線程A對共享變量所做修改的)消息。

線程B獲取一個鎖,實質上是線程B接收了之前某個線程發出的(在釋放這個鎖之前對共享變量所做修改的)消息。

線程A釋放鎖,隨后線程B獲取這個鎖,這個過程實質上是線程A通過主內存向線程B發送消息。

鎖內存語義的實現

本文將借助ReentrantLock的源代碼,來分析鎖內存語義的具體實現機制。

請看下面的示例代碼:

class ReentrantLockExample {
int a = 0;
ReentrantLock lock = new ReentrantLock();

public void writer() {
    lock.lock();         //獲取鎖
    try {
        a++;
    } finally {
        lock.unlock();  //釋放鎖
    }
}

public void reader () {
    lock.lock();        //獲取鎖
    try {
        int i = a;
        ……
    } finally {
        lock.unlock();  //釋放鎖
    }
}
}

在ReentrantLock中,調用lock()方法獲取鎖;調用unlock()方法釋放鎖。

ReentrantLock的實現依賴于java同步器框架AbstractQueuedSynchronizer(本文簡稱之為AQS)。AQS使用一個整型的volatile變量(命名為state)來維護同步狀態,馬上我們會看到,這個volatile變量是ReentrantLock內存語義實現的關鍵。 下面是ReentrantLock的類圖(僅畫出與本文相關的部分):

ReentrantLock分為公平鎖和非公平鎖,我們首先分析公平鎖。

使用公平鎖時,加鎖方法lock()的方法調用軌跡如下:

ReentrantLock : lock()

FairSync : lock()

AbstractQueuedSynchronizer : acquire(int arg)

ReentrantLock : tryAcquire(int acquires)

在第4步真正開始加鎖,下面是該方法的源代碼:

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();   //獲取鎖的開始,首先讀volatile變量state
    if (c == 0) {
        if (isFirst(current) &&
            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;
}

從上面源代碼中我們可以看出,加鎖方法首先讀volatile變量state。

在使用公平鎖時,解鎖方法unlock()的方法調用軌跡如下:

ReentrantLock : unlock()

AbstractQueuedSynchronizer : release(int arg)

Sync : tryRelease(int releases)

在第3步真正開始釋放鎖,下面是該方法的源代碼:

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);           //釋放鎖的最后,寫volatile變量state
    return free;
}

從上面的源代碼我們可以看出,在釋放鎖的最后寫volatile變量state。

公平鎖在釋放鎖的最后寫volatile變量state;在獲取鎖時首先讀這個volatile變量。根據volatile的happens-before規則,釋放鎖的線程在寫volatile變量之前可見的共享變量,在獲取鎖的線程讀取同一個volatile變量后將立即變的對獲取鎖的線程可見。

現在我們分析非公平鎖的內存語義的實現。

非公平鎖的釋放和公平鎖完全一樣,所以這里僅僅分析非公平鎖的獲取。

使用非公平鎖時,加鎖方法lock()的方法調用軌跡如下:

ReentrantLock : lock()

NonfairSync : lock()

AbstractQueuedSynchronizer : compareAndSetState(int expect, int
update)

在第3步真正開始加鎖,下面是該方法的源代碼:

protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

該方法以原子操作的方式更新state變量,本文把java的compareAndSet()方法調用簡稱為CAS。JDK文檔對該方法的說明如下:如果當前狀態值等于預期值,則以原子方式將同步狀態設置為給定的更新值。此操作具有 volatile 讀和寫的內存語義。

這里我們分別從編譯器和處理器的角度來分析,CAS如何同時具有volatile讀和volatile寫的內存語義。

前文我們提到過,編譯器不會對volatile讀與volatile讀后面的任意內存操作重排序;編譯器不會對volatile寫與volatile寫前面的任意內存操作重排序。組合這兩個條件,意味著為了同時實現volatile讀和volatile寫的內存語義,編譯器不能對CAS與CAS前面和后面的任意內存操作重排序。

下面我們來分析在常見的intel x86處理器中,CAS是如何同時具有volatile讀和volatile寫的內存語義的。

下面是sun.misc.Unsafe類的compareAndSwapInt()方法的源代碼:

public final native boolean compareAndSwapInt(Object o, long offset,
                                              int expected,
                                              int x);

可以看到這是個本地方法調用。這個本地方法在openjdk中依次調用的c++代碼為:unsafe.cpp,atomic.cpp和atomic*windows*x86.inline.hpp。這個本地方法的最終實現在openjdk的如下位置:openjdk-7-fcs-src-b147-27*jun*2011openjdkhotspotsrcos*cpuwindows*x86vmatomic*windows*x86.inline.hpp(對應于windows操作系統,X86處理器)。下面是對應于intel x86處理器的源代碼的片段:

// Adding a lock prefix to an instruction on MP machine
// VC++ doesn"t like the lock prefix to be on a single line
// so we can"t insert a label after the lock prefix.
// By emitting a lock prefix, we can define a label after it.
#define LOCK_IF_MP(mp) __asm cmp mp, 0  
                       __asm je L0      
                       __asm _emit 0xF0 
                       __asm L0:

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  // alternative for InterlockedCompareExchange
  int mp = os::is_MP();
  __asm {
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    LOCK_IF_MP(mp)
    cmpxchg dword ptr [edx], ecx
  }
}

如上面源代碼所示,程序會根據當前處理器的類型來決定是否為cmpxchg指令添加lock前綴。如果程序是在多處理器上運行,就為cmpxchg指令加上lock前綴(lock cmpxchg)。反之,如果程序是在單處理器上運行,就省略lock前綴(單處理器自身會維護單處理器內的順序一致性,不需要lock前綴提供的內存屏障效果)。

intel的手冊對lock前綴的說明如下:

確保對內存的讀-改-寫操作原子執行。在Pentium及Pentium之前的處理器中,帶有lock前綴的指令在執行期間會鎖住總線,使得其他處理器暫時無法通過總線訪問內存。很顯然,這會帶來昂貴的開銷。從Pentium 4,Intel Xeon及P6處理器開始,intel在原有總線鎖的基礎上做了一個很有意義的優化:如果要訪問的內存區域(area of memory)在lock前綴指令執行期間已經在處理器內部的緩存中被鎖定(即包含該內存區域的緩存行當前處于獨占或以修改狀態),并且該內存區域被完全包含在單個緩存行(cache line)中,那么處理器將直接執行該指令。由于在指令執行期間該緩存行會一直被鎖定,其它處理器無法讀/寫該指令要訪問的內存區域,因此能保證指令執行的原子性。這個操作過程叫做緩存鎖定(cache locking),緩存鎖定將大大降低lock前綴指令的執行開銷,但是當多處理器之間的競爭程度很高或者指令訪問的內存地址未對齊時,仍然會鎖住總線。

禁止該指令與之前和之后的讀和寫指令重排序。

把寫緩沖區中的所有數據刷新到內存中。

上面的第2點和第3點所具有的內存屏障效果,足以同時實現volatile讀和volatile寫的內存語義。

經過上面的這些分析,現在我們終于能明白為什么JDK文檔說CAS同時具有volatile讀和volatile寫的內存語義了。

現在對公平鎖和非公平鎖的內存語義做個總結:

公平鎖和非公平鎖釋放時,最后都要寫一個volatile變量state。

公平鎖獲取時,首先會去讀這個volatile變量。

非公平鎖獲取時,首先會用CAS更新這個volatile變量,這個操作同時具有volatile讀和volatile寫的內存語義。

從本文對ReentrantLock的分析可以看出,鎖釋放-獲取的內存語義的實現至少有下面兩種方式:

利用volatile變量的寫-讀所具有的內存語義。

利用CAS所附帶的volatile讀和volatile寫的內存語義。

concurrent包的實現

由于java的CAS同時具有 volatile 讀和volatile寫的內存語義,因此Java線程之間的通信現在有了下面四種方式:

A線程寫volatile變量,隨后B線程讀這個volatile變量。

A線程寫volatile變量,隨后B線程用CAS更新這個volatile變量。

A線程用CAS更新一個volatile變量,隨后B線程用CAS更新這個volatile變量。

A線程用CAS更新一個volatile變量,隨后B線程讀這個volatile變量。

Java的CAS會使用現代處理器上提供的高效機器級別原子指令,這些原子指令以原子方式對內存執行讀-改-寫操作,這是在多處理器中實現同步的關鍵(從本質上來說,能夠支持原子性讀-改-寫指令的計算機器,是順序計算圖靈機的異步等價機器,因此任何現代的多處理器都會去支持某種能對內存執行原子性讀-改-寫操作的原子指令)。同時,volatile變量的讀/寫和CAS可以實現線程之間的通信。把這些特性整合在一起,就形成了整個concurrent包得以實現的基石。如果我們仔細分析concurrent包的源代碼實現,會發現一個通用化的實現模式:

首先,聲明共享變量為volatile;

然后,使用CAS的原子條件更新來實現線程之間的同步;

同時,配合以volatile的讀/寫和CAS所具有的volatile讀和寫的內存語義來實現線程之間的通信。

AQS,非阻塞數據結構和原子變量類(java.util.concurrent.atomic包中的類),這些concurrent包中的基礎類都是使用這種模式來實現的,而concurrent包中的高層類又是依賴于這些基礎類來實現的。從整體來看,concurrent包的實現示意圖如下:

參考文獻

?Concurrent Programming in Java: Design Principles and Pattern

?JSR 133 (Java Memory Model) FAQ

?JSR-133: Java Memory Model and Thread Specification

?Java Concurrency in Practice

?Java? Platform, Standard Edition 6 API Specification

?The JSR-133 Cookbook for Compiler Writers

?Intel? 64 and IA-32 ArchitecturesvSoftware Developer’s Manual Volume 3A: System Programming Guide, Part 1

?The Art of Multiprocessor Programming

關于作者

程曉明,Java軟件工程師,國家認證的系統分析師、信息項目管理師。專注于并發編程,個人郵箱:asst2003@163.com。

請看下篇 深入理解Java內存模型(六)——final

via ifeve

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/66150.html

相關文章

  • 深入理解Java內存模型(四)—— volatile

    摘要:前情提要深入理解內存模型三順序一致性的特性當我們聲明共享變量為后,對這個變量的讀寫將會很特別。當讀線程的數量大大超過寫線程時,選擇在寫之后插入屏障將帶來可觀的執行效率的提升。 前情提要 深入理解Java內存模型(三)——順序一致性 volatile的特性 當我們聲明共享變量為volatile后,對這個變量的讀/寫將會很特別。理解volatile特性的一個好方法是:把對volatil...

    K_B_Z 評論0 收藏0
  • 深入理解volatile類型——從Java虛擬機內存模型角度

    摘要:本文從內存模型角度,探討的實現原理。通過共享內存或者消息通知這兩種方法,可以實現通信或同步。基于共享內存的線程通信是隱式的,線程同步是顯式的而基于消息通知的線程通信是顯式的,線程同步是隱式的。鎖規則鎖的解鎖,于于鎖的獲取或加鎖。 一、前言 在java多線程編程中,volatile可以用來定義輕量級的共享變量,它比synchronized的使用成本更低,因為它不會引起線程上下文的切換和調...

    mushang 評論0 收藏0
  • Java】幾道讓你拿offer的面試題

    摘要:的方法,的默認實現會判斷是否是類型注意自動拆箱,自動裝箱問題。適應自旋鎖鎖競爭是下的,會經過用戶態到內核態的切換,是比較花時間的。在中引入了自適應的自旋鎖,說明自旋的時間不固定,要不要自旋變得越來越聰明。 前言 只有光頭才能變強 之前在刷博客的時候,發現一些寫得比較好的博客都會默默收藏起來。最近在查閱補漏,有的知識點比較重要的,但是在之前的博客中還沒有寫到,于是趁著閑整理一下。 文本的...

    張春雷 評論0 收藏0
  • 我的阿里之路+Java面經考點

    摘要:我的是忙碌的一年,從年初備戰實習春招,年三十都在死磕源碼,三月份經歷了阿里五次面試,四月順利收到實習。因為我心理很清楚,我的目標是阿里。所以在收到阿里之后的那晚,我重新規劃了接下來的學習計劃,將我的短期目標更新成拿下阿里轉正。 我的2017是忙碌的一年,從年初備戰實習春招,年三十都在死磕JDK源碼,三月份經歷了阿里五次面試,四月順利收到實習offer。然后五月懷著忐忑的心情開始了螞蟻金...

    姘擱『 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<