中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

ReentrantLock源碼分析Java多線程

發布時間:2023-04-19 16:35:42 來源:億速云 閱讀:102 作者:iii 欄目:開發技術

這篇“ReentrantLock源碼分析Java多線程”文章的知識點大部分人都不太理解,所以小編給大家總結了以下內容,內容詳細,步驟清晰,具有一定的借鑒價值,希望大家閱讀完這篇文章能有所收獲,下面我們一起來看看這篇“ReentrantLock源碼分析Java多線程”文章吧。

管程

管程(Monitor)是一種用于實現多線程同步的抽象數據類型,它可以用來協調不同線程之間的互斥和同步訪問共享資源。通俗地說,管程就像一個門衛,控制著進入某個共享資源區域的線程數量和時間,以避免多個線程同時訪問導致的數據競爭和混亂。

管程模型

  • Mesa管程模型:由美國計算機科學家Dijkstra提出,是最流行的管程模型之一。在Mesa管程模型中,每個管程也有一個條件變量和等待隊列,但與Hoare管程不同的是,當一個線程請求進入管程時,如果條件不滿足,該線程并不會立即被阻塞,而是繼續執行后續操作,直到該線程主動放棄鎖資源或者其他線程喚醒它。

  • Hoare管程模型:由英國計算機科學家C.A.R. Hoare提出,是最早的管程模型之一。在Hoare管程模型中,每個管程都有一個條件變量和一個等待隊列,當一個線程請求進入管程時,如果條件不滿足,該線程就會被阻塞并加入等待隊列,直到條件滿足后才被喚醒。

  • Brinch Hansen管程模型:由丹麥計算機科學家Per Brinch Hansen提出,是一種改進的管程模型。在Brinch Hansen管程模型中,每個管程也有一個條件變量和等待隊列,但與其他管程模型不同的是,它允許多個線程同時在管程中等待,并且不需要像Hoare管程那樣每次只喚醒一個等待線程。

在Java中,采用的是基于Mesa管程模型實現的管程機制。具體地,Java中的synchronized關鍵字就是基于Mesa管程模型實現的,包括Java中的AbstractQueuedSynchronizer(AQS)可以被看作是一種基于管程模型實現的同步框架。

MESA模型

主要特點

  • 互斥訪問

MESA模型采用了互斥訪問的機制,即同一時刻只能有一個線程進入管程執行代碼。

  • 條件變量

MESA模型還引入了條件變量的概念,用于實現線程間的等待和喚醒操作。條件變量提供了一種機制,使得線程可以在等待某個條件成立時掛起,并在條件成立時被喚醒。

  • 等待隊列

MESA模型使用等待隊列來維護處于等待狀態的線程,這些線程都在等待條件變量成立。等待隊列由一個或多個條件變量組成,每個條件變量都有自己的等待隊列。

  • 原子操作

MESA模型要求管程中的所有操作都是原子操作,即一旦進入管程,就不能被中斷,直到操作執行完畢。

ReentrantLock源碼分析Java多線程

AQS

在講ReentrantLock之前先說一下AQS,AQS(AbstractQueuedSynchronizer)是Java中的一個同步器,它是許多同步類(如ReentrantLock、Semaphore、CountDownLatch等)的基礎。AQS提供了一種實現同步操作的框架,其中包括獨占模式和共享模式,以及一個等待隊列來管理線程的等待和喚醒。AQS也借鑒了Mesa模型的思想。

共享變量

AQS內部維護了屬性volatile int state表示資源的可用狀態
state三種訪問方式:

  • getState()

  • setState()

  • compareAndSetState()

資源訪問方式

Exclusive-獨占,只有一個線程能執行,如ReentrantLock

Share-共享,多個線程可以同時執行,如Semaphore/CountDownLatch

主要方法

  • isHeldExclusively():該線程是否正在獨占資源。只有用到condition才需要去實現它。

  • tryAcquire(int):獨占方式。嘗試獲取資源,成功則返回true,失敗則返回false。

  • tryRelease(int):獨占方式。嘗試釋放資源,成功則返回true,失敗則返回false。

  • tryAcquireShared(int):共享方式。嘗試獲取資源。負數表示失敗;0表示成功,但沒有剩余可用資源;正數表示成功,且有剩余資源。

  • tryReleaseShared(int):共享方式。嘗試釋放資源,如果釋放后允許喚醒后續等待結點返回true,否則返回false

隊列

  • 同步等待隊列: 主要用于維護獲取鎖失敗時入隊的線程。

  • 條件等待隊列: 調用await()的時候會釋放鎖,然后線程會加入到條件隊列,調用signal()喚醒的時候會把條件隊列中的線程節點移動到同步隊列中,等待再次獲得鎖。

node節點等待狀態

  • 值為0,初始化狀態,表示當前節點在sync隊列中,等待著獲取鎖。

  • CANCELLED,值為1,表示當前的線程被取消;

  • SIGNAL,值為-1,表示當前節點的后繼節點包含的線程需要運行,也就是unpark;

  • CONDITION,值為-2,表示當前節點在等待condition,也就是在condition隊列中;

  • PROPAGATE,值為-3,表示當前場景下后續的acquireShared能夠得以執行;

ReentrantLock源碼分析

在ReentrantLock中有一個內部類Sync會繼承 AQS然后將同步器所有調用都映射到Sync對應的方法。

實例化ReentrantLock

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}
/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

ReentrantLock還提供了一個傳布爾值的實例化方式,這個傳true用來創建一個公平鎖的,默認是創建非公平鎖。非公平鎖的話 sync是用NonfairSync來進行實例化,公平鎖sync是用FairSync來進行實例化。

加鎖

現在假設有AB兩個線程來競爭鎖

A線程加鎖成功

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        //CAS修改state狀態
        if (compareAndSetState(0, 1))
           //修改成功設置exclusiveOwnerThread
            setExclusiveOwnerThread(Thread.currentThread());
        else
           //嘗試獲取資源
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

假定A線程先CAS修改成功,他會設置exclusiveOwnerThread為A線程

ReentrantLock源碼分析Java多線程

B線程嘗試加鎖

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

我們先看tryAcquire()方法,這里體現出了他的可重入性。

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    //獲取當前資源標識
    int c = getState();
    if (c == 0) {
        //如果資源沒被占有CAS嘗試加鎖
        if (compareAndSetState(0, acquires)) {
            //修改成功設置exclusiveOwnerThread
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //資源被占有要判斷占有資源的線程是不是當前線程,加鎖成功設置的exclusiveOwnerThread值在這里就派上了用處
    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;
}

根據上面源碼我們可以看出B線程嘗試加鎖是失敗的,接下來看嘗試加鎖失敗后的方法acquireQueued(addWaiter(Node.EXCLUSIVE), arg),該方法實現分為兩個部分:

  • addWaiter(Node.EXCLUSIVE):該方法會將當前線程加入到等待隊列(即 Sync 中的 queue)的尾部,并返回該節點。這個節點的模式是獨占模式(Node.EXCLUSIVE),表示當前線程想要獲取獨占鎖。

  • acquireQueued(Node node, int arg):該方法是一個循環方法,用于等待和獲取鎖。

我們先解析addWaiter

private Node addWaiter(Node mode) {
    //構建一個當前線程的node節點 這里prev 和 next 都為null
    Node node = new Node(Thread.currentThread(), mode);
    // 指向雙向鏈表的尾節點的引用
    Node pred = tail;
    //B線程進來目前還未構建任何隊列這里肯定是空的
    if (pred != null) {
        //如果已經構建過隊列會把當前線程的node節點的上一個node節點指向tail尾節點
        node.prev = pred;
        //CAS操作把當前線程的node節點設置為新的tail尾節點
        if (compareAndSetTail(pred, node)) {
            //把舊的tail尾節點的下一個node節點指向當前線程的node節點
            pred.next = node;
            return node;
        }
    }
    //尾節點為空執行
    enq(node);
    return node;
}
private Node enq(final Node node) {
    //死循環當tail 尾節點不為空才會跳出
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            //用CAS構建出一個head空的node節點
            if (compareAndSetHead(new Node()))
            //將當前空的node節點交給尾節點(下一次循環就會走else分支)
                tail = head;
        } else {
            //把我們addWaiter中創建的node節點的prev指向了當前線程node節點
            node.prev = t;
            //將tail尾節點更改為當前線程的node節點
            if (compareAndSetTail(t, node)) {
                //將t的下一個節點指向當前線程創建的node節點
                t.next = node;
                return t;
            }
        }
    }
}

執行完這里初步的一個等待隊列就構建好了

ReentrantLock源碼分析Java多線程

解析完addWaiter我們再來解析acquireQueued,addWaiter執行完后的結果會返回一個雙向列表的node節點

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        //中斷標志位
        boolean interrupted = false;
        for (;;) {
            //獲取當前線程node節點的上一個節點
            final Node p = node.predecessor();
            //如果上一個節點就是head節點說明當前線程其實是處在隊列第一位然后就會再次嘗試加鎖
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //這里是重點 這個方法來判斷當前線程是否應該進入等待狀態
            if (shouldParkAfterFailedAcquire(p, node) &&
                //調用LockSupport.park(this)阻塞了當前線程等待被喚醒
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //獲取上一個節點的等待狀態
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)//表示當前節點的后繼節點包含的線程需要運行
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) {//當前線程被取消
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//設置等待狀態為-1
    }
    return false;
}

運行到parkAndCheckInterrupt()B線程就會被阻塞了,后續的邏輯我們在解鎖操作unlock之后再繼續說

ReentrantLock源碼分析Java多線程

釋放鎖

public void unlock() {
    sync.release(1);
}
public final boolean release(int arg) {
   //嘗試釋放鎖
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //head節點不為空并且等待狀態不是0就去進行unpark操作
            unparkSuccessor(h);
        return true;
    }
    return false;
}
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    //head節點等待狀態
    int ws = node.waitStatus;
    //
    if (ws < 0)
       //將頭節點的等待狀態修改為0
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    //獲取頭節點的下一個節點(也就是B節點)
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {//節點為空或者線程處于取消狀態
        s = null;
        //從尾節點往上找符合條件的節點
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        //對該線程進行unpark喚醒(B節點)
        LockSupport.unpark(s.thread);
}

ReentrantLock源碼分析Java多線程

喚醒之后我們的B線程就能繼續往下走了,我們繼續看剛剛的acquireQueued()方法

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            //這里嘗試獲取鎖由于A線程釋放了鎖這里是肯定獲取成功的
            if (p == head && tryAcquire(arg)) {
                //把head設置為當前節點(也就是往前移一位,并且把上一個節點指向指為null)
                setHead(node);
                //把剛剛的上一個節點也指向為null (這里他就沒引用了會被GC回收掉)
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                //剛剛在這里阻塞現在被喚醒
                parkAndCheckInterrupt())
                //設置標志中斷位為true 然后開始下一次循環
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

以上就是關于“ReentrantLock源碼分析Java多線程”這篇文章的內容,相信大家都有了一定的了解,希望小編分享的內容對大家有幫助,若想了解更多相關的知識內容,請關注億速云行業資訊頻道。

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

云浮市| 德钦县| 新绛县| 东乡族自治县| 祥云县| 尚义县| 尼木县| 津市市| 福州市| 湾仔区| 道孚县| 孝义市| 郑州市| 白河县| 临武县| 新宾| 锡林浩特市| 天门市| 水富县| 原平市| 论坛| 玉环县| 灵台县| 鄂温| 杭锦旗| 邢台市| 曲麻莱县| 汉沽区| 湟源县| 会理县| 灵璧县| 江城| 丹巴县| 拉萨市| 阿坝县| 满洲里市| 吴旗县| 苍山县| 山东省| 南阳市| 咸宁市|