2. 程式人生 > >ReentrantLock原始碼分析

ReentrantLock原始碼分析

阿新 • • 發佈：2020-01-20

概述

ReentrantLock是一個可重入的互斥鎖，也被稱為獨佔鎖。它支援公平鎖和非公平鎖兩種模式。

ReentrantLock的使用方法

下面看一個最初級的例子：

public class Test {

    //預設內部採用非公平實現
    ReentrantLock lock=new ReentrantLock();
    
    public void myMethor(){
        lock.lock();

        //需要加鎖的一些操作
        
        //一定要確保unlock能被執行到，尤其是在存在異常的情況下
        lock.unlock();
    }
}

在進入方法後，在需要加鎖的一些操作執行之前需要呼叫lock方法，在jdk文件中對lock方法詳細解釋如下：

獲得鎖。
如果鎖沒有被另一個執行緒佔用並且立即返回，則將鎖定計數設定為1。 如果當前執行緒已經保持鎖定，則保持計數增加1，該方法立即返回。 如果鎖被另一個執行緒保持，則當前執行緒將被禁用以進行執行緒排程，並且在鎖定已被獲取之前處於休眠狀態，此時鎖定保持計數被設定為1。

這裡也很好的解釋了什麼是可重入鎖，如果一個執行緒已經持有了鎖，它再次請求獲取自己已經拿到的鎖，是能夠獲取成功的，這就是可重入鎖。

在需要加鎖的程式碼執行完畢之後，就會呼叫unlock釋放掉鎖。在jdk文件之中對，unlock的解釋如下：

嘗試釋放此鎖。
如果當前執行緒是該鎖的持有者，則保持計數遞減。 如果保持計數現在為零，則鎖定被釋放。 如果當前執行緒不是該鎖的持有者，則丟擲IllegalMonitorStateException 。

在這裡有一個需要注意的地點，lock和unlock都反覆提到了一個計數，這主要是因為ReentrantLock是可重入的。每次獲取鎖（重入）就將計數器加一，每次釋放的時候的計數器減一，直到計數器為0，就將鎖釋放掉了。

以上就是最基礎，最簡單的使用方法。其餘的一些方法，都是一些拓展的功能，檢視jdk文件即可知道如何使用。

原始碼分析

繼承體系


可以看出ReentrantLock繼承自AQS並實現了Lock介面。它內部有公平鎖和非公平鎖兩種實現，這兩種實現都是繼承自Sync。根據ReentrantLock決定到底採用公平鎖還是非公平鎖實現。

 public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

核心方法原始碼分析

Lock方法

  1. 首先呼叫具體的Lock實現.sync可能是非公平鎖實現也可能是公平鎖實現，這取決於你new物件時的引數。
    public void lock() {
        sync.lock();
    }

我們以非公平鎖實現來看下面的下面的程式碼。

  1. 非公平鎖的lock方法的具體實現如下
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

首先進來就是一個判斷，其中判斷的條件就是compareAndSetState(0, 1).毫無疑問這是一個CAS。它的意思時如果當前的state的值的為0就將1與其交換（可以理解為將1賦值給0）並返回true。其實在這一步如果state的值修改成功了，那麼鎖就獲取成功了。setExclusiveOwnerThread(Thread.currentThread())這行程式碼就是將當前執行緒設定為該排他鎖的擁有者。

如果CAS失敗了，那麼就呼叫acquire(1);

  1. 如果初次獲得鎖失敗就呼叫qcquire(1)
    這個方法的具體實現如下；
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

這個方法進來首先第一步就是呼叫tryAcquire(arg).
那麼該方法是幹什麼的呢？
非公平鎖實際是呼叫了這個實現：

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

它具體的實現是在nonfairTryAcquire(acquires)中。

 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState(); //獲取鎖的狀態state，這就是前面我們CAS的操作物件
            if (c == 0) {
                //c==0說明沒被其它獲取
                if (compareAndSetState(0, acquires)) { //CAS修改state
                    //CAS修改成功，說明獲取鎖成功，將當前執行緒設定為該排他鎖的擁有者
                    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;
            }
            //鎖被其它執行緒佔有，就返回false
            return false;
        }
  1. 第二次嘗試獲取鎖失敗後，就進行下一步操作
    我們再會過頭看void acquire(int arg)首先嚐試獲取鎖，獲取成功就直接返回了，獲取失敗就會執行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)進行排隊。
    這一行程式碼可以分為兩部分看，一部分是addWaiter(Node.EXCLUSIVE)一部分是acquireQueued.我們先看addWaiter(Node.EXCLUSIVE)
 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;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node; //返回
            }
        }
        //佇列沒有初始化，初始化佇列併入隊
        enq(node);
        return node;
    }

初始化對立對入隊的具體實現如下：

    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                //初始化佇列
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
            //佇列初始化成功，進行入隊
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

這裡稍微補充一下這個AQS中的這個等待佇列。

  1. 節點也建立了，等待佇列也入了
    現在該看boolean acquireQueued(final Node node, int arg)方法了。
    這個方法的具體實現如下：
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)) {
                //如果當前節點的前一個節點是頭節點，就會執行tryAcquire(arg)再次嘗試獲取鎖
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    //根據情況進入park狀態
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

unlock方法

  1. 和加鎖類似，呼叫具體的實現
    public void unlock() {
        sync.release(1);
    }
  1. 具體的release實現
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                //喚醒等待的執行緒，可以拿鎖了
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

該方法首先就呼叫了tryRelease(arg)方法，這個方法就是實現釋放資源的關鍵。釋放的具體操作，也印證了在jdk文件之中的關於unlock和lock的說明。

protected final boolean tryRelease(int releases) {
            int c = getState() - releases; //計算釋放後的state的值
            if (Thread.currentThread() != getExclusiveOwnerThread())
                //如果當前執行緒沒有持有鎖，就拋異常
                throw new IllegalMonitorStateException();
            boolean free = false; //標記為釋放失敗
            if (c == 0) {
                //如果state為0了，說沒沒有執行緒佔有該鎖了
                //進行重置所有者
                free = true;
                setExclusiveOwnerThread(null);
            }
            //重置state的值
            setState(c);
            return free;
        }
  1. 如果還有執行緒在等待鎖資源，那麼就可以喚醒它們了
    回到boolean release(int arg)看
 if (h != null && h.waitStatus != 0)
                //喚醒等待的執行緒，可以拿鎖了
                unparkSuccessor(h);

ReentrantLock的高階使用方法

我們使用synchronized的時候，可以通過wait和notify來讓執行緒等待，和喚醒執行緒。在ReentrantLock中，我們也可以使用Condition中的await和signal來使執行緒等待和喚醒。
以下面這段程式碼來解釋：


public class Test {

    static ReentrantLock lock=new ReentrantLock();
    //獲取到condition
    static Condition condition=lock.newCondition();

    public static class TaskA implements Runnable{

        @Override
        public void run() {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "開始執行");
            try {
                System.out.println(Thread.currentThread().getName() + "準備釋放掉鎖並等待");
                //在此等待，直到其它執行緒喚醒
                condition.await();
                System.out.println(Thread.currentThread().getName() + "重新拿到鎖並執行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
    }


    public static class TaskB implements Runnable{

        @Override
        public void run() {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "開始執行");

            System.out.println(Thread.currentThread().getName() + "開始喚醒等待的執行緒");
            //喚醒等待的執行緒
            condition.signal();
            try {
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "任務執行完畢");
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
       
        Thread taskA=new Thread(new TaskA(),"taskA");
        Thread taskB=new Thread(new TaskB(),"taskB");
        taskA.start();
        taskB.start();
    }
    
}

輸出結果：

taskA開始執行
taskA準備釋放掉鎖並等待
taskB開始執行
taskB開始喚醒等待的執行緒
taskB任務執行完畢
taskA重新拿到鎖並執行

現象解釋：
首先taskA拿到鎖，並執行，到condition.await();釋放鎖，並進入阻塞。taskB因此拿到剛才taskA釋放掉的鎖，taskB開始執行。taskB執行到condition.signal();喚醒了taskA，taskB繼續執行，taskA因為拿不到鎖，因此雖然已經被喚醒了，但是還是要等到taskB執行完畢，釋放鎖後，才有機會拿到鎖，執行自己的程式碼。

那麼這個過程，原始碼到底是如何實現的呢？

Condition原始碼分析

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)) {
            //如果當前執行緒不在等待佇列中，park阻塞
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break; //執行緒被中斷就跳出迴圈
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                //取消條件佇列中已經取消的等待節點的連結
                unlinkCancelledWaiters();
            if (interruptMode != 0)
            //等待結束後處理中斷
                reportInterruptAfterWait(interruptMode);
        }

基本的步驟如下：

  1. 首先判斷執行緒是否被中斷，如果中斷則丟擲InterruptedException()異常
  2. 添加當前執行緒到條件佇列中去，然後釋放掉所有的資源
  3. 如果當前執行緒不在等待佇列中，就直接park阻塞當前執行緒

signal()方法原始碼分析

具體的實現程式碼如下：

        public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

這個方法中最重要的也就是doSignal(first).
它的實現如下：

        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null; //解除等待佇列中首節點的連結
            } while (!transferForSignal(first) && //轉移入等待佇列
                     (first = firstWaiter) != null);
        }

該方法所做的事情就是從等待佇列中移除指定節點，並將其加入等待佇列中去。
轉移節點的方法實現如下：

    final boolean transferForSignal(Node node) {
        /*
         * If cannot change waitStatus, the node has been cancelled.
         */
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            //CAS修改狀態失敗，說明節點被取消了，直接返回false
            return false;

        /*
         * Splice onto queue and try to set waitStatus of predecessor to
         * indicate that thread is (probably) waiting. If cancelled or
         * attempt to set waitStatus fails, wake up to resync (in which
         * case the waitStatus can be transiently and harmlessly wrong).
         */
        Node p = enq(node); //加入節點到等待佇列
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        //如果前節點被取消，說明當前為最後一個等待執行緒，直接unpark喚醒，
            LockSupport.unpark(node.thread);
        return true;
    }

至此ReentrantLock的原始碼分析就結束了

相關推薦

ReentrantLock 原始碼分析

ReentrantLock 1）ReentrantLock 類實現了和 synchronized 一樣的記憶體語義，同時該類提供了更加靈活多樣的可重入互斥鎖定操作。 2）ReentrantLock 例項可以被同一個執行緒多次獲取，因此是可重入的互斥鎖。 例項建立 /** * 建立一個非

【本人禿頂程式設計師】Java併發系列 | ReentrantLock原始碼分析

←←←←←←←←←←←← 我都禿頂了，還不點關注！ 在Java5.0之前，協調對共享物件的訪問可以使用的機制只有synchronized和volatile。我們知道synchronized關鍵字實現了內建鎖，而volatile關鍵字保證了多執行緒的記憶體可見性。 在大多數情況下，這些

JUC的AQS學習-ReentrantLock原始碼分析

什麼是AQS AQS是JUC裡併發控制一個很重要的基礎，他提供了一個獨佔和共享訪問控制某個狀態的工具，JUC裡的鎖、訊號量、門閥都是基於AQS實現的，單獨去看AQS的程式碼很難理解，而且很難理解其設計之精妙，筆者計劃依次分析鎖(ReentrantLock)、門閥(CountDownLatch)

ReentrantLock原始碼分析（公平鎖）

ReentranLock通過lock來獲取鎖，下面就通過lock來分析公平鎖的過程1、lock()方法 final void lock() { acquire(1); }lock()方法通過acquire()方法來獲取鎖，acquire

JAVA 併發類（六） ReentrantLock 原始碼分析

ReentrantLock實現了Lock介面，是一種遞迴無阻塞的同步機制。 首先ReentrantLock有公平鎖和非公平鎖機制，使用構造方法ReentrantLock(boolean)指定，預設是非公平鎖。 公平鎖的含義是執行緒按照發出請求的先後順序獲取鎖

JUC原始碼分析(二)-ReentrantLock原始碼分析

背景介紹 ReentrantLock是JUC中的重要的類,其靜態內部類Sync繼承AQS,關於AQS的分析可見JUC-AbstractQueuedSynchronizer(AQS)原始碼分析,Sync重寫了tryAcquire()和tryReleas

可重入的獨佔鎖——ReentrantLock原始碼分析

ReentrantLock面試題分析 1、ReentrantLock是怎麼實現的？ 2、ReentrantLock的

ReentrantLock 原始碼分析從入門到入土

回答一個問題 在開始本篇文章的內容講述前，先來回答我一個問題，為什麼 JDK 提供一個 synchronized 關鍵字之後還要提供一個 Lock 鎖，這不是多此一舉嗎？難道 JDK 設計人員都是沙雕嗎？ 我聽過一句話非常的經典，也是我認為是每個人都應該瞭解的一句話：你以為的並不是你以為的。明白什麼意思麼？不

ReentrantLock原始碼分析

概述 ReentrantLock是一個可重入的互斥鎖，也被稱為獨佔鎖。它支援公平鎖和非公平鎖兩種模式。 ReentrantLock的使用方法 下面看一個最初級的例子： public class Test { //預設內部採用非公平實現 ReentrantLock lock=new Reen

ReentrantLock 原始碼分析以及 AQS （一）

## 前言 JDK1.5 之後釋出了JUC（java.util.concurrent），用於解決多執行緒併發問題。AQS 是一個特別重要的同步框架，很多同步類都藉助於 AQS 實現了對執行緒同步狀態的管理。 AQS 中最主要的就是獨佔鎖和共享鎖的獲取和釋放，以及提供了一些可中斷的獲取鎖，超時等待鎖等方法。

多執行緒高併發程式設計(3) -- ReentrantLock原始碼分析AQS

背景： 　　AbstractQueuedSynchronizer(AQS) public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Seri

JUC之ReentrantLock原始碼分析

ReentrantLock：實現了Lock介面，是一個可重入鎖，並且支援執行緒公平競爭和非公平競爭兩種模式，預設情況下是非公平模式。ReentrantLock算是synchronized的補充和替代方案。 公平競爭：遵從先來後到的規則，先到先得非公平競爭：正常情況下是先到先得，但是允許見縫插針。即持有鎖的執行

併發程式設計（三）—— ReentrantLock實現原理及原始碼分析

　　ReentrantLock是Java併發包中提供的一個可重入的互斥鎖。ReentrantLock和synchronized在基本用法，行為語義上都是類似的，同樣都具有可重入性。只不過相比原生的Synchronized，ReentrantLock增加了一些高階的擴充套件功能，比如它可以實現公平鎖，同時也可以

AbstractQueuedSynchronizer原始碼分析（ReentrantLock鎖的實現）

1.  前言 Java中好多地方用到AbstractQueuedSynchronizer（PS：簡稱AQS），比如ReentrantLock、執行緒池，這部分在面試的時候也經常被問到，今天以ReentrantLock為例，通過原始碼來加深對AQS的理解 2.  lock 通常，我們的用法是這

ReentrantLock實現原理及原始碼分析

       ReentrantLock實現原理及原始碼分析        ReentrantLock是Java併發包中提供的一個可重入的互斥鎖。ReentrantLock和synchronized在基本用法，行為語

Java多執行緒之ReentrantLock實現原理和原始碼分析（二）

章節概覽、 1、ReentrantLock概述 ReentrantLock字面含義是可重入的互斥鎖，實現了和synchronize關鍵字一樣的獨佔鎖功能。但是ReentrantLock使用的是自旋鎖，通過CAS硬體原語指令實現的輕量級的鎖，不會引起上下文切換

【JDK】JDK原始碼分析-ReentrantLock

概述   在 JDK 1.5 以前，鎖的實現只能用 synchronized 關鍵字；1.5 開始提供了 ReentrantLock，它是 API 層面的鎖。先看下 ReentrantLock 的類簽名以及如何使用： public class ReentrantLock implemen

ReentrantLock解析及原始碼分析

##本文結構 - Tips：說明一部分概念及閱讀原始碼需要的基礎內容 - ReentrantLock簡介 - 公平機制：對於公平機制和非公平機制進行介紹，包含對比 - 實現：`Sync`原始碼解析額，公平和非公平模式的加鎖、解鎖過程及原始碼分析 - 公平鎖和非公平鎖的加鎖流程圖 - `ReentrantLoc

java   ReentrantLock   分析

java reentrantlock 機制 多線程並發編程中經常用到的莫非是這個ReentrantLock這個類，線程獲取鎖和釋放鎖。還有一個則是synchronized，常用來多線程控制獲取鎖機制。先寫一個簡單的例子。package com.multi.thread; import java.util.

mybatis原理，配置介紹及原始碼分析

前言 mybatis核心元件有哪些？它是工作原理是什麼？ mybatis配置檔案各個引數是什麼含義？ mybatis只添加了介面類，沒有實現類，為什麼可以直接查詢呢？ mybatis的mapper對映檔案各個引數又是什麼含義？ mybatis-spring提供哪些機制簡化了原生mybatis？ m