2. 程式人生 > >ReentrantReadWriteLock讀寫鎖的使用

ReentrantReadWriteLock讀寫鎖的使用

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

　　類ReentrantLock具有完全互斥排他的效果，即同一時間只有一個執行緒在執行ReentrantLock.lock()後面的程式碼。這樣雖然保證了執行緒的安全性，但是效率低下。JDK提供了ReentrantReadWriteLock讀寫鎖，使用它可以加快效率，在某些不需要操作例項變數的方法中，完全可以使用讀寫鎖ReemtrantReadWriteLock來提升該方法的執行速度。

　　讀寫鎖表示有兩個鎖，一個是讀操作相關的鎖，也稱為共享鎖；另一個是寫操作相關的鎖，也叫排他鎖。也就是多個讀鎖之間不互斥，讀鎖與寫鎖互斥、寫鎖與寫鎖互斥。在沒有執行緒Thread進行寫入操作時，進行讀取操作的多個Thread都可以獲取讀鎖，而進行寫入操作的Thread只有在獲取寫鎖後才能進行寫入操作。即多個Thread可以同時進行讀取操作，但是同一時刻只允許一個Thread進行寫入操作。

1.讀讀共享

　　讀鎖與讀鎖可以共享，這種鎖一般用於只讀操作，不對變數進行修改操作。

package cn.qlq.thread.twelve;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cn.qlq.thread.one.RunnableThread;

public class Demo1 {
    private ReentrantReadWriteLock lock = new
 
 ReentrantReadWriteLock();// 讀寫鎖
    private static final Logger log = LoggerFactory.getLogger(Demo1.class);

    private int i;

    public String readI() {
        try {
            lock.readLock().lock();// 佔用讀鎖
            log.info("threadName -> {} 佔用讀鎖,i->{}", Thread.currentThread().getName(), i);
            Thread.sleep(
 
2 * 1000);
        } catch (InterruptedException e) {

        } finally {
            log.info("threadName -> {} 釋放讀鎖,i->{}", Thread.currentThread().getName(), i);
            lock.readLock().unlock();// 釋放讀鎖
        }
        return i + "";
    }

    public static void main(String[] args) {
        final Demo1 demo1 = new Demo1();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                demo1.readI();
            }
        };

        new Thread(runnable, "t1").start();
        new Thread(runnable, "t2").start();
        new Thread(runnable, "t3").start();

    }

}

結果:

18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t2 佔用讀鎖,i->0
18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t1 佔用讀鎖,i->0
18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t3 佔用讀鎖,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t3 釋放讀鎖,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t1 釋放讀鎖,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t2 釋放讀鎖,i->0

 

2.寫寫互斥

　　寫鎖與寫鎖互斥，這就類似於ReentrantLock的作用效果。

package cn.qlq.thread.twelve;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Demo2 {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 讀寫鎖
    private static final Logger log = LoggerFactory.getLogger(Demo2.class);

    private int i;

    public void addI() {
        try {
            lock.writeLock().lock();// 佔用寫鎖
            log.info("threadName -> {} 佔用寫鎖,i->{}", Thread.currentThread().getName(), i);
            Thread.sleep(2 * 1000);
            i++;
        } catch (InterruptedException e) {

        } finally {
            log.info("threadName -> {} 釋放寫鎖,i->{}", Thread.currentThread().getName(), i);
            lock.writeLock().unlock();// 釋放寫鎖
        }
    }

    public static void main(String[] args) {
        final Demo2 demo1 = new Demo2();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                demo1.addI();
            }
        };

        new Thread(runnable, "t1").start();
        new Thread(runnable, "t2").start();
        new Thread(runnable, "t3").start();

    }

}

結果:(從時間可以看出實現了互斥效果)

18:31:31 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t1 佔用寫鎖,i->0
18:31:33 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t1 釋放寫鎖,i->1
18:31:33 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t2 佔用寫鎖,i->1
18:31:35 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t2 釋放寫鎖,i->2
18:31:35 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t3 佔用寫鎖,i->2
18:31:37 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t3 釋放寫鎖,i->3

 

3.讀寫互斥

package cn.qlq.thread.twelve;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 讀寫互斥
 * 
 * @author Administrator
 *
 */
public class Demo3 {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 讀寫鎖
    private static final Logger log = LoggerFactory.getLogger(Demo3.class);

    private int i;

    public String readI() {
        try {
            lock.readLock().lock();// 佔用讀鎖
            log.info("threadName -> {} 佔用讀鎖,i->{}", Thread.currentThread().getName(), i);
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {

        } finally {
            log.info("threadName -> {} 釋放讀鎖,i->{}", Thread.currentThread().getName(), i);
            lock.readLock().unlock();// 釋放讀鎖
        }
        return i + "";
    }

    public void addI() {
        try {
            lock.writeLock().lock();// 佔用寫鎖
            log.info("threadName -> {} 佔用寫鎖,i->{}", Thread.currentThread().getName(), i);
            Thread.sleep(2 * 1000);
            i++;
        } catch (InterruptedException e) {

        } finally {
            log.info("threadName -> {} 釋放寫鎖,i->{}", Thread.currentThread().getName(), i);
            lock.writeLock().unlock();// 釋放寫鎖
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final Demo3 demo1 = new Demo3();

        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.readI();
            }
        }, "t1").start();

        Thread.sleep(1 * 1000);

        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.addI();
            }
        }, "t2").start();

    }

}

結果:

18:34:59 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 佔用讀鎖,i->0
18:35:01 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 釋放讀鎖,i->0
18:35:01 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 佔用寫鎖,i->0
18:35:03 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 釋放寫鎖,i->1

 

4.寫讀互斥

　　寫鎖與讀鎖也是互斥的。先佔用寫鎖後讀鎖進行搶佔也會等待寫鎖釋放。

package cn.qlq.thread.twelve;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 讀寫互斥
 * 
 * @author Administrator
 *
 */
public class Demo3 {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 讀寫鎖
    private static final Logger log = LoggerFactory.getLogger(Demo3.class);

    private int i;

    public String readI() {
        try {
            lock.readLock().lock();// 佔用讀鎖
            log.info("threadName -> {} 佔用讀鎖,i->{}", Thread.currentThread().getName(), i);
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {

        } finally {
            log.info("threadName -> {} 釋放讀鎖,i->{}", Thread.currentThread().getName(), i);
            lock.readLock().unlock();// 釋放讀鎖
        }
        return i + "";
    }

    public void addI() {
        try {
            lock.writeLock().lock();// 佔用寫鎖
            log.info("threadName -> {} 佔用寫鎖,i->{}", Thread.currentThread().getName(), i);
            Thread.sleep(2 * 1000);
            i++;
        } catch (InterruptedException e) {

        } finally {
            log.info("threadName -> {} 釋放寫鎖,i->{}", Thread.currentThread().getName(), i);
            lock.writeLock().unlock();// 釋放寫鎖
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final Demo3 demo1 = new Demo3();

        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.addI();
            }
        }, "t2").start();

        Thread.sleep(1 * 1000);

        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.readI();
            }
        }, "t1").start();
    }

}

結果:

18:36:14 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 佔用寫鎖,i->0
18:36:16 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 釋放寫鎖,i->1
18:36:16 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 佔用讀鎖,i->1
18:36:18 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 釋放讀鎖,i->1

 

總結:　讀寫、寫讀、寫寫都是互斥的，而讀讀是非同步非互斥的。

　　    也就是隻要有寫鎖的參與就會進行同步，所以寫鎖也被稱為排他鎖，讀鎖被稱為共享鎖。

 

相關推薦

ReentrantReadWriteLock 讀寫鎖解析

　　java中鎖是個很重要的概念，當然這裡的前提是你會涉及併發程式設計。 　　除了語言提供的鎖關鍵字 synchronized和volatile之外，jdk還有其他多種實用的鎖。 　　不過這些鎖大多都是基於AQS佇列同步器。ReadWriteLock 讀寫鎖就是其中一個。 　　讀寫鎖的含義是，將讀鎖與寫

ReentrantReadWriteLock 讀寫鎖

ReentrantReadWriteLock 讀寫鎖 讀寫鎖不同於 ReentrantLock ，ReentrantLock 是排他鎖同一時刻只允許一個執行緒訪問，而讀寫鎖同一時刻允許多個讀執行緒訪問，但是在寫執行緒操作時，所有的讀寫操作均被阻塞。 讀寫狀態實現 如何通過一個 int 值

ReentrantReadWriteLock讀寫鎖的使用

　　類ReentrantLock具有完全互斥排他的效果，即同一時間只有一個執行緒在執行ReentrantLock.lock()後面的程式碼。這樣雖然保證了執行緒的安全性，但是效率低下。JDK提供了ReentrantReadWriteLock讀寫鎖，使用它可以加快效率，在某些不需要操作例項變數的方法中，完全可以

ReentrantReadWriteLock讀寫鎖詳解

一、讀寫鎖簡介     現實中有這樣一種場景：對共享資源有讀和寫的操作，且寫操作沒有讀操作那麼頻繁。在沒有寫操作的時候，多個執行緒同時讀一個資源沒有任何問題，所以應該允許多個執行緒同時讀取共享資源；但是如果一個執行緒想去寫這些共享資源，就不應該允許其他執行緒對該資源進行讀和寫

java多執行緒：併發包中ReentrantReadWriteLock讀寫鎖的鎖降級模板

寫鎖降級為讀鎖，但讀鎖不可升級或降級為寫鎖。 鎖降級是為了讓當前執行緒感知到資料的變化。 1 //讀寫鎖 2 private ReentrantReadWriteLock lock=new ReentrantReadWriteLock(); 3 //讀鎖 4

java多執行緒：併發包中ReentrantReadWriteLock讀寫鎖的鎖降級模板 寫鎖降級為讀鎖

寫鎖降級為讀鎖，但讀鎖不可升級或降級為寫鎖。 鎖降級是為了讓當前執行緒感知到資料的變化。 1 //讀寫鎖 2 private ReentrantReadWriteLock lock=new ReentrantReadWriteLock(); 3 /

【轉載】ReentrantReadWriteLock讀寫鎖的使用

Lock比傳統執行緒模型中的synchronized方式更加面向物件，與生活中的鎖類似，鎖本身也應該是一個物件。兩個執行緒執行的程式碼片段要實現同步互斥的效果，它們必須用同一個Lock物件。 　　讀寫鎖：分為讀鎖和寫鎖，多個讀鎖不互斥，讀鎖與寫鎖互斥，這是由jvm自己控制的

java併發鎖ReentrantReadWriteLock讀寫鎖原始碼分析

public void unlock() { sync.releaseShared(1); } //AbstractQueuedSynchronizer的 realseShared方法 public final boolean releaseShared(int arg) {

AQS系列（三）- ReentrantReadWriteLock讀寫鎖的加鎖

前言     前兩篇我們講述了ReentrantLock的加鎖釋放鎖過程，相對而言比較簡單，本篇進入深水區，看看ReentrantReadWriteLock-讀寫鎖的加鎖過程是如何實現的，繼續拜讀老Lea凌厲的程式碼風。 一、讀寫鎖的類圖     讀鎖就是共享鎖，而寫鎖

AQS系列（四）- ReentrantReadWriteLock讀寫鎖的釋放鎖

前言     繼續JUC包中ReentrantReadWriteLock的學習，今天學習釋放鎖。 一、寫鎖釋放鎖     入口方法 1 public void unlock() { 2 sync.release(1); 3 }

ReentrantReadWriteLock讀寫鎖簡單原理案例證明

## ReentrantReadWriteLock存在原因？ --- 我們知道List的實現類ArrayList，LinkedList都是非執行緒安全的，Vector類通過用synchronized修飾方法保證了List的多執行緒非安全問題，但是有個缺點：**讀寫同步，效率低下**。於是就出現了CopyO

高並發編程-09-讀寫鎖ReentrantReadWriteLock

案例 https order span app ant shu 概念 border 1，讀寫鎖的概念我們之前講的鎖是排他鎖或叫互斥鎖而我們今天要講的ReentrantReadWriteLock讀寫鎖兼顧了排他鎖和共享鎖的特性，對於讀的操作采用的是共享鎖，而寫的操作采用的是排

讀寫鎖 ReentrantReadWriteLock

readers bee 初始 unit 隊列 .net tps countdown volatile 一、讀寫鎖 ReadWriteLock概念特點讀寫鎖維護了一對相關的鎖，一個用於只讀操作，一個用於寫入操作。只要沒有writer，讀取鎖可以由多個reader線程同時保持。

[源碼分析]讀寫鎖ReentrantReadWriteLock

ktr next hashmap wait 異常 move 同時 有時 func 一.簡介 讀寫鎖. 讀鎖之間是共享的. 寫鎖是獨占的. 首先聲明一點: 我在分析源碼的時候, 把jdk源碼復制出來進行中文的註釋, 有時還進行編譯調試什麽的, 為了避免和jdk原生的類混

讀寫鎖--ReentrantReadWriteLock

讀寫鎖，對於讀操作來說是共享鎖，對於寫操作來說是排他鎖，兩種操作都可重入的一種鎖。底層也是用AQS來實現的，我們來看一下它的結構跟程式碼： -------------------------------------------------------------------------------

鎖的優化 ReentrantReadWriteLock（讀寫鎖） 資料共享通道：BlockingQueue

在併發的程式應用中，鎖的競爭必然導致程式的效能下降。為了將這種副作用降到最低，下面提出一些建議可以幫助大家寫出效能更加優越的程式。 減少鎖持有的時間 　　對於使用鎖進行併發控制的應用程式而言，在鎖競爭的過程中，單個執行緒對鎖的持有時間與系統性能有著直接的關係。如果執行緒持有鎖的時間很長，那麼相對的，鎖的競

Java 讀寫鎖 ReentrantReadWriteLock 原始碼分析

本文內容：讀寫鎖 ReentrantReadWriteLock 的原始碼分析，基於 Java7/Java8。 閱讀建議：雖然我這裡會介紹一些 AQS 的知識，不過如果你完全不瞭解 AQS，看本文就有點吃力了。 使用示例 下面這個例子非常實用，我是 javadoc 的

（2.1.27.11）Java併發程式設計：Lock之ReentrantReadWriteLock 讀寫分離獨享式重入鎖

我們在介紹AbstractQueuedSynchronizer的時候介紹過，AQS支援獨佔式同步狀態獲取/釋放、共享式同步狀態獲取/釋放兩種模式，對應的典型應用分別是ReentrantLock和Semaphore AQS還可以混合兩種模式使用，讀寫鎖Reent

Java併發程式設計之鎖機制之ReentrantReadWriteLock（讀寫鎖）

前言 在前面的文章中，我們講到了ReentrantLock(重入鎖)，接下來我們講ReentrantReadWriteLock（讀寫鎖），該鎖具備重入鎖的可重入性、可中斷獲取鎖等特徵，但是與ReentrantLock不一樣的是，在ReentrantReadWriteLock中，維護了一對鎖，一個讀鎖一個寫鎖

心心念的讀寫鎖：ReentrantReadWriteLock

今天本來是想去戶外穿越看楓葉的，但報名晚了又加上今天天氣不太好，未去成。 無所事事，於是，就想把之前未曾細看過的讀寫鎖看一下。 1、前言 讀完了以上兩篇文章，先看一下ReentrantReadWriteLock的程式碼路徑： package java.util