2. 程式人生 > >Java併發ReadWriteLock讀寫鎖的與Synchronized

Java併發ReadWriteLock讀寫鎖的與Synchronized

阿新 • • 發佈：2018-12-19

說到Java併發程式設計，很多開發第一個想到同時也是經常常用的肯定是Synchronized，但是小編這裡提出一個問題，Synchronized存在明顯的一個性能問題就是讀與讀之間互斥，簡言之就是，我們程式設計想要實現的最好效果是，可以做到讀和讀互不影響，讀和寫互斥，寫和寫互斥，提高讀寫的效率，如何實現呢？

Java併發包中ReadWriteLock是一個介面，主要有兩個方法，如下：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

ReadWriteLock管理一組鎖，一個是隻讀的鎖，一個是寫鎖。 Java併發庫中ReetrantReadWriteLock實現了ReadWriteLock介面並添加了可重入的特性。 在具體講解ReetrantReadWriteLock的使用方法前，我們有必要先對其幾個特性進行一些深入學習瞭解。

1. ReetrantReadWriteLock特性說明

1.1 獲取鎖順序

  • 非公平模式（預設） 當以非公平初始化時，讀鎖和寫鎖的獲取的順序是不確定的。非公平鎖主張競爭獲取，可能會延緩一個或多個讀或寫執行緒，但是會比公平鎖有更高的吞吐量。
  • 公平模式 當以公平模式初始化時，執行緒將會以佇列的順序獲取鎖。噹噹前執行緒釋放鎖後，等待時間最長的寫鎖執行緒就會被分配寫鎖；或者有一組讀執行緒組等待時間比寫執行緒長，那麼這組讀執行緒組將會被分配讀鎖。

1.2 可重入

什麼是可重入鎖，不可重入鎖呢？"重入"字面意思已經很明顯了，就是可以重新進入。可重入鎖，就是說一個執行緒在獲取某個鎖後，還可以繼續獲取該鎖，即允許一個執行緒多次獲取同一個鎖。比如synchronized內建鎖就是可重入的，如果A類有2個synchornized方法method1和method2，那麼method1呼叫method2是允許的。顯然重入鎖給程式設計帶來了極大的方便。假如內建鎖不是可重入的，那麼導致的問題是：1個類的synchornized方法不能呼叫本類其他synchornized方法，也不能呼叫父類中的synchornized方法。與內建鎖對應，JDK提供的顯示鎖ReentrantLock也是可以重入的，這裡通過一個例子著重說下可重入鎖的釋放需要的事兒。

package test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test1 {

    public static void main(String[] args) throws InterruptedException {
        final ReentrantReadWriteLock  lock = new ReentrantReadWriteLock ();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.writeLock().lock();
                System.out.println("Thread real execute");
                lock.writeLock().unlock();
            }
        });

        lock.writeLock().lock();
        lock.writeLock().lock();
        t.start();
        Thread.sleep(200);
        
        System.out.println("realse one once");
        lock.writeLock().unlock();
    }

}

執行結果.png

從執行結果中，可以看到，程式並未執行執行緒的run方法，由此我們可知，上面的程式碼會出現死鎖，因為主執行緒2次獲取了鎖，但是卻只釋放1次鎖，導致執行緒t永遠也不能獲取鎖。一個執行緒獲取多少次鎖，就必須釋放多少次鎖。這對於內建鎖也是適用的，每一次進入和離開synchornized方法(程式碼塊)，就是一次完整的鎖獲取和釋放。

再次新增一次unlock之後的執行結果.png

1.3 鎖降級

要實現一個讀寫鎖，需要考慮很多細節，其中之一就是鎖升級和鎖降級的問題。什麼是升級和降級呢？ReadWriteLock的javadoc有一段話：

Can the write lock be downgraded to a read lock without allowing an intervening writer? Can a read lock be upgraded to a write lock, in preference to other waiting readers or writers?

翻譯過來的結果是：在不允許中間寫入的情況下，寫入鎖可以降級為讀鎖嗎？讀鎖是否可以升級為寫鎖，優先於其他等待的讀取或寫入操作？簡言之就是說，鎖降級：從寫鎖變成讀鎖；鎖升級：從讀鎖變成寫鎖，ReadWriteLock是否支援呢？讓我們帶著疑問，進行一些Demo 測試程式碼驗證。

Test Code 1

/**
 *Test Code 1
 **/
package test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test1 {

    public static void main(String[] args) {
        ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();
        rtLock.readLock().lock();
        System.out.println("get readLock.");
        rtLock.writeLock().lock();
        System.out.println("blocking");
    }
}

Test Code 1 Result

TestCode1 Result.png

結論：上面的測試程式碼會產生死鎖，因為同一個執行緒中，在沒有釋放讀鎖的情況下，就去申請寫鎖，這屬於鎖升級，ReentrantReadWriteLock是不支援的。

Test Code 2

/**
 *Test Code 2
 **/
package test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test2 {

    public static void main(String[] args) {
        ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();  
        rtLock.writeLock().lock();  
        System.out.println("writeLock");  
          
        rtLock.readLock().lock();  
        System.out.println("get read lock");  
    }
}

Test Code 2 Result

TestCode2 Result.png

結論：ReentrantReadWriteLock支援鎖降級，上面程式碼不會產生死鎖。這段程式碼雖然不會導致死鎖，但沒有正確的釋放鎖。從寫鎖降級成讀鎖，並不會自動釋放當前執行緒獲取的寫鎖，仍然需要顯示的釋放，否則別的執行緒永遠也獲取不到寫鎖。

2. ReetrantReadWriteLock對比使用

2.1 Synchronized實現

在使用ReetrantReadWriteLock實現鎖機制前，我們先看一下，多執行緒同時讀取檔案時，用synchronized實現的效果

package test;

/**
 * 
 * synchronized實現
 * @author itbird
 *
 */
public class ReadAndWriteLockTest {

    public synchronized static void get(Thread thread) {
        System.out.println("start time:" + System.currentTimeMillis());
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(thread.getName() + ":正在進行讀操作……");
        }
        System.out.println(thread.getName() + ":讀操作完畢！");
        System.out.println("end time:" + System.currentTimeMillis());
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                get(Thread.currentThread());
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                get(Thread.currentThread());
            }
        }).start();
    }

}

讓我們看一下執行結果：

synchronized實現的效果結果.png

從執行結果可以看出，兩個執行緒的讀操作是順序執行的，整個過程大概耗時200ms。

2.2 ReetrantReadWriteLock實現

package test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 
 * ReetrantReadWriteLock實現
 * @author itbird
 *
 */
public class ReadAndWriteLockTest {

    public static void get(Thread thread) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        lock.readLock().lock();
        System.out.println("start time:" + System.currentTimeMillis());
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(thread.getName() + ":正在進行讀操作……");
        }
        System.out.println(thread.getName() + ":讀操作完畢！");
        System.out.println("end time:" + System.currentTimeMillis());
        lock.readLock().unlock();
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                get(Thread.currentThread());
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                get(Thread.currentThread());
            }
        }).start();
    }

}

讓我們看一下執行結果：

ReetrantReadWriteLock實現.png

從執行結果可以看出，兩個執行緒的讀操作是同時執行的，整個過程大概耗時100ms。通過兩次實驗的對比，我們可以看出來，ReetrantReadWriteLock的效率明顯高於Synchronized關鍵字。

3. ReetrantReadWriteLock讀寫鎖互斥關係

通過上面的測試程式碼，我們也可以延伸得出一個結論，ReetrantReadWriteLock讀鎖使用共享模式，即：同時可以有多個執行緒併發地讀資料。但是另一個問題來了，寫鎖之間是共享模式還是互斥模式？讀寫鎖之間是共享模式還是互斥模式呢？下面讓我們通過Demo進行一一驗證吧。

3.1 ReetrantReadWriteLock讀寫鎖關係

package test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 
 * ReetrantReadWriteLock實現
 * @author itbird
 *
 */
public class ReadAndWriteLockTest {

    public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        //同時讀、寫
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                readFile(Thread.currentThread());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                writeFile(Thread.currentThread());
            }
        });
    }

    // 讀操作
    public static void readFile(Thread thread) {
        lock.readLock().lock();
        boolean readLock = lock.isWriteLocked();
        if (!readLock) {
            System.out.println("當前為讀鎖！");
        }
        try {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在進行讀操作……");
            }
            System.out.println(thread.getName() + ":讀操作完畢！");
        } finally {
            System.out.println("釋放讀鎖！");
            lock.readLock().unlock();
        }
    }

    // 寫操作
    public static void writeFile(Thread thread) {
        lock.writeLock().lock();
        boolean writeLock = lock.isWriteLocked();
        if (writeLock) {
            System.out.println("當前為寫鎖！");
        }
        try {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在進行寫操作……");
            }
            System.out.println(thread.getName() + ":寫操作完畢！");
        } finally {
            System.out.println("釋放寫鎖！");
            lock.writeLock().unlock();
        }
    }
}

執行結果：

執行結果.png

結論：讀寫鎖的實現必須確保寫操作對讀操作的記憶體影響。換句話說，一個獲得了讀鎖的執行緒必須能看到前一個釋放的寫鎖所更新的內容，讀寫鎖之間為互斥。

3.2 ReetrantReadWriteLock寫鎖關係

package test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 
 * ReetrantReadWriteLock實現
 * @author itbird
 *
 */
public class ReadAndWriteLockTest {

    public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        //同時寫
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                writeFile(Thread.currentThread());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                writeFile(Thread.currentThread());
            }
        });
    }

    // 讀操作
    public static void readFile(Thread thread) {
        lock.readLock().lock();
        boolean readLock = lock.isWriteLocked();
        if (!readLock) {
            System.out.println("當前為讀鎖！");
        }
        try {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在進行讀操作……");
            }
            System.out.println(thread.getName() + ":讀操作完畢！");
        } finally {
            System.out.println("釋放讀鎖！");
            lock.readLock().unlock();
        }
    }

    // 寫操作
    public static void writeFile(Thread thread) {
        lock.writeLock().lock();
        boolean writeLock = lock.isWriteLocked();
        if (writeLock) {
            System.out.println("當前為寫鎖！");
        }
        try {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在進行寫操作……");
            }
            System.out.println(thread.getName() + ":寫操作完畢！");
        } finally {
            System.out.println("釋放寫鎖！");
            lock.writeLock().unlock();
        }
    }
}

執行結果：

執行結果.png

4. 總結

1.Java併發庫中ReetrantReadWriteLock實現了ReadWriteLock介面並添加了可重入的特性 2.ReetrantReadWriteLock讀寫鎖的效率明顯高於synchronized關鍵字 3.ReetrantReadWriteLock讀寫鎖的實現中，讀鎖使用共享模式；寫鎖使用獨佔模式，換句話說，讀鎖可以在沒有寫鎖的時候被多個執行緒同時持有，寫鎖是獨佔的 4.ReetrantReadWriteLock讀寫鎖的實現中，需要注意的，當有讀鎖時，寫鎖就不能獲得；而當有寫鎖時，除了獲得寫鎖的這個執行緒可以獲得讀鎖外，其他執行緒不能獲得讀鎖

作者：itbird01 連結：https://www.jianshu.com/p/9cd5212c8841 來源：簡書 簡書著作權歸作者所有，任何形式的轉載都請聯絡作者獲得授權並註明出處。

相關推薦

Java併發ReadWriteLock讀寫鎖的與Synchronized

說到Java併發程式設計，很多開發第一個想到同時也是經常常用的肯定是Synchronized，但是小編這裡提出一個問題，Synchronized存在明顯的一個性能問題就是讀與讀之間互斥，簡言之就是，我們程式設計想要實現的最好效果是，可以做到讀和讀互不影響，讀和寫互斥，寫和寫

JAVA 併發程式設計-讀寫鎖之模擬快取系統（十一）

    在多執行緒中，為了提高效率有些共享資源允許同時進行多個讀的操作，但只允許一個寫的操作，比如一個檔案，只要其內容不變可以讓多個執行緒同時讀，不必做排他的鎖定，排他的鎖定只有在寫的時候需要，以保證別

Java併發程式設計-讀寫鎖

1.認識讀寫鎖讀寫鎖既是一個排他鎖也是一個共享鎖，讀鎖是共享鎖，寫鎖是排他鎖。讀操作可以共存，讀操作和寫操作互斥，寫操作和寫操作之間互斥。下面是一個使用例子：public class Demo {    private Map<String, Object> ma

java併發學習02---ReadWriteLock 讀寫鎖

同步器--讀寫鎖 java併發包中幫我們進行了一系列的封裝，之前的重入鎖需要我們手動的加鎖和釋放鎖，而同步器只需要我們簡單的去使用就可以了。 之前我們無論是使用synchronized還是ReentrantLock，都是對整個操作進行了加鎖，但我們可以想象到，如果兩個執行緒都進行的知識讀取的操作，那麼實際

Java 多執行緒高併發 3.5 — ReadWriteLock 讀寫鎖使用

ReadWriteLock 又稱為共享鎖，的讀寫分離鎖，內部分為讀鎖和寫鎖 關於 A 和 B 執行緒，讀和寫的關係 A 讀 — B 讀：不互斥、不阻塞 A 讀 — B 寫：互斥，互相阻塞 A 寫 — B 寫：互斥，互相阻塞 用法：非常簡單，和 Reentra

java併發程式設計系列之ReadWriteLock讀寫鎖的使用

前面我們講解了Lock的使用，下面我們來講解一下ReadWriteLock鎖的使用，顧明思義，讀寫鎖在讀的時候，上讀鎖，在寫的時候，上寫鎖，這樣就很巧妙的解決synchronized的一個性能問題：讀與讀之間互斥。 ReadWriteLock也是一個介面，原型如下： pub

Java執行緒總結（八）：併發包------讀寫鎖ReadWriteLock的簡單例子詳細理解

初次接觸ReadWriteLock類時也在網上查了很多資料，很容易瞭解到ReadWriteLock是讀寫鎖，並且讀寫鎖的機制有以下三個特點：  讀鎖---讀鎖    （不互斥）  讀鎖---寫鎖     （互斥）  寫鎖---寫鎖     （互斥）什麼意思呢？網上很多資料，

22、Java並發性和多線程-Java中的讀/寫鎖

權限 原理 目的 str sco readers 閱讀 操作 wait 以下內容轉自http://ifeve.com/read-write-locks/： 相比Java中的鎖(Locks in Java)裏Lock實現，讀寫鎖更復雜一些。假設你的程序中涉及到對一些共享資源

Java並發- 讀寫鎖中的性能之王：StampedLock

第一個 jdk1.8 轉換 cpu 原生 判斷 四種 空間 blog 為什麽StampedLock這麽神奇？能夠達到這種效果，它的核心思想在於，在讀的時候如果發生了寫，應該通過重試的方式來獲取新的值，而不應該阻塞寫操作。這種模式也就是典型的無鎖編程思想，和CAS自旋的思想一

ReadWriteLock讀寫鎖

ReadWriteLock管理的是一組鎖，一個是讀鎖，一個是寫鎖。 當前兩個鎖是同時使用的。 其實很多人能理解寫鎖，因為寫鎖的話，寫如果併發的話，那就出現髒資料。 不過為什麼會存在讀鎖？讀為什麼要鎖？ 其實資料有完整性。 比如： public class Man {

JAVA併發程式設計：悲觀鎖與樂觀鎖

生活 晴。 悲觀與樂觀的情緒概念 本篇來了解一下悲觀鎖和樂觀鎖，在瞭解這兩個鎖之前，我們首先有必要把悲觀和樂觀這兩個詞搞清楚： 悲觀：對世事懷有消極的看法，認為事物總往糟糕的方向發展。 樂觀：對世事懷有積極的態度，認為事物總往好的方向發展。 何為悲觀鎖 悲觀鎖： 假定會發

Java併發——執行緒同步Volatile與Synchronized詳解

0. 前言 轉載請註明出處：http://blog.csdn.net/seu_calvin/article/details/52370068 面試時很可能遇到這樣一個問題：使用volatile修飾int型變數i，多個執行緒同時進行i++操作，這樣可以實現執行緒安全嗎？提到

Java併發程式設計(八)------無鎖與無鎖類(原子操作類)

1. 無鎖的概念 無鎖主要有兩個特徵： 是無障礙的 保證有一個執行緒可以勝出 與無障礙相比，無障礙並不保證有競爭時一定能完成操作，因為如果它發現每次操作都會產生衝突，那它則會不停地嘗試。如果臨界區內的執行緒互相干擾，則會導致所有的執行緒會卡死在臨界區，那麼系統性能則

java動手實現讀寫鎖

基於synchronized實現讀寫鎖 昨天面試小米基礎平臺，面試官問了一個這樣的題目，讓我自己實現一個讀寫鎖，用lock實現。想了半天lock不會，最後改用synchronized實現  讀寫

Java中的讀寫鎖

import java.util.concurrent.locks.ReentrantReadWriteLock; public class TestRWL { public static void

boost庫讀寫鎖與互斥鎖的用法解析

#include <boost/thread/mutex.hpp> #include <boost/thread/shared_mutex.hpp> typedef boost::shared_mutex WR_Mutex;

10、JUC--ReadWriteLock 讀寫鎖

同時 更新 -- try 數據安全 並發 all 其中 runnable 讀-寫鎖 ReadWriteLock ? ReadWriteLock 維護了一對相關的鎖，一個用於只讀操作，　　另一個用於寫入操作。只要沒有 writer，讀取鎖可以由　　多個 reader 線程同

java併發-Synchronized+CAS方式實現讀寫鎖

Synchronized+CAS方式實現讀寫鎖 文章目錄 Synchronized+CAS方式實現讀寫鎖 思路 技術 程式碼 測試 結果 [GitHub主頁](https://gith

java讀寫鎖ReadWriteLock

blog ner java readwrite pan exce oid rate this package com.java.concurrent; import java.util.concurrent.locks.ReadWriteLock; import jav

java多線程---讀寫鎖ReadWriteLock

iter 獲得 throw pan fin class err mem catch public interface ReadWriteLock ReadWriteLock 維護了一對相關的鎖，一個用於只讀操作，另一個用於寫入操作。只要沒有 writer，讀取鎖可以由多個