并发编程学习案例-ReentrantReadWriteLock非公平的情况下读锁插队和写锁插队场景复现

已于 2023-02-03 23:51:28 修改
阅读量512 收藏
点赞数
分类专栏： java 文章标签： 学习 java 开发语言
于 2023-02-03 23:47:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LvQiFen/article/details/128874683
版权
本文通过代码示例展示了JavaReentrantReadWriteLock在非公平模式下，写锁可以随时插队，而读锁仅在等待队列头节点不是写线程时可以插队的现象。作者通过模拟多线程场景，证实了写线程和特定条件下读线程的插队行为。
摘要由CSDN通过智能技术生成

文章目录

一、前言

Java ReentrantReadWriteLock 是 ReadWriteLock 的实现类，可以分出2把锁，ReentrantReadWriteLock.ReadLock 读锁和 ReentrantReadWriteLock.WriteLock写锁。我们知道读读之间可以共享，读写、写写是互斥的，这样并发度比 ReentrantLock 这种互斥锁更高。ReentrantReadWriteLock在Java 中锁分公平和非公平：

  • 在公平的场景下，多个线程会排队按顺进行加锁和释放锁；
  • 在非公平的场景下如果排队中的线程在唤醒期间还未唤醒时，此时如果有其它写线程加入则无需进入对列等待可插队获取到锁；如果在唤醒期间还未唤醒时，排队的队列里头节点是读线程，此时如果有其它读线程加入则无需进入对列等待可插队获取到读锁；。这里复现 ReentrantReadWriteLock 读锁在特定的场景下插队的场景复现

总结：

  • 写锁可以随时插队
  • 读锁仅在等待对列头节点不是想获取写锁的线程的时候可以进行插队

二、源码

ReentrantReadWriteLock 的源码里非公平的实现，writeShouldBlock()写总能插队，readerShouldBlock()读在当前对列第一个线程是排它时，可以进行插队，下面给出代码演示案例

在这里插入图片描述

三、 代码案例

（一）复现写的时候插队场景

依次启动线程一（写线程），线程二线程三（读线程），线程四（写线程），线程五线程六（读线程），然后再启动一个子线程来创建1K个写线程进行尝试写。
线程一先获取写锁，其它线程则进入对列阻塞等待，当线程一处理完毕释放锁的瞬间，如果有非中文的写线程在线程二三四五六前先获取到写线程，则说明，这些写线程进行了插队。

package com.lvzb.lock;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 非公平的读写锁，写锁插队 和 读锁插队案例
 *
 * @author: lvzb31988
 * @date: 2023/02/03 17:16
 */
public class NofaireBargeDemoTest {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(false);
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    public void read() {
        System.out.println(Thread.currentThread().getName() + "尝试获取读锁");
        readLock.lock();
        try {
            TimeUnit.MILLISECONDS.sleep(20);
            System.out.println(Thread.currentThread().getName() + " 获取到了读锁...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }

    public void write() {
        System.out.println(Thread.currentThread().getName() + "尝试获取写锁");
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 获取到了写锁...");
            TimeUnit.MILLISECONDS.sleep(45);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " 释放到了写锁...");
            writeLock.unlock();
        }
    }

    /**
     * 模拟出来 写锁插队的场景
     *
     * @throws InterruptedException
     */
    @Test
    void nofairTest1() throws InterruptedException {
        NofaireBargeDemoTest bargeDemo = new NofaireBargeDemoTest();

        List<Thread> arr = new ArrayList<>();
        new Thread(bargeDemo::write, "线程一").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程二").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程三").start();
        Thread.sleep(5);
        new Thread(bargeDemo::write, "线程四").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程五").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程六").start();
        new Thread(() -> {
            for (int i = 0; i < 800; i++) {
                new Thread(bargeDemo::write, "线程" + i).start();
            }
        }).start();


        TimeUnit.SECONDS.sleep(50);
    }
    
}
参考执行结果

日志打印结果 第一个写线程释放瞬间，被其376号刚创建的写线程给获取执行，而没有直接执行队列里早已等待的读线程二和三


线程一尝试获取写锁
线程一 获取到了写锁...
线程二尝试获取读锁
线程三尝试获取读锁
线程四尝试获取写锁
线程五尝试获取读锁
线程六尝试获取读锁
线程0尝试获取写锁
线程1尝试获取写锁
线程2尝试获取写锁
线程3尝试获取写锁
线程4尝试获取写锁
线程5尝试获取写锁
线程6尝试获取写锁
线程7尝试获取写锁
线程8尝试获取写锁
..........
线程371尝试获取写锁
线程289尝试获取写锁
线程373尝试获取写锁
线程374尝试获取写锁
线程375尝试获取写锁
线程一 释放到了写锁...
线程376尝试获取写锁
线程377尝试获取写锁
线程376 获取到了写锁...
线程161尝试获取写锁
线程474尝试获取写锁
线程473尝试获取写锁
线程472尝试获取写锁
线程475尝试获取写锁
..........
线程768尝试获取写锁
线程792尝试获取写锁
线程790尝试获取写锁
线程793尝试获取写锁
线程794尝试获取写锁
线程758尝试获取写锁
线程789尝试获取写锁
线程784尝试获取写锁
线程776尝试获取写锁
线程786尝试获取写锁
线程779尝试获取写锁
线程760尝试获取写锁
线程781尝试获取写锁
线程778尝试获取写锁
线程783尝试获取写锁
线程788尝试获取写锁
线程785尝试获取写锁
线程787尝试获取写锁
线程780尝试获取写锁
线程376 释放到了写锁...
线程二 获取到了读锁...
线程三 获取到了读锁...
线程四 获取到了写锁...
线程四 释放到了写锁...
线程五 获取到了读锁...
线程六 获取到了读锁...
线程0 获取到了写锁...
线程0 释放到了写锁...
线程1 获取到了写锁...
.......

（二）复现读的时候插队

依次启动线程一（写线程），线程二线程三（读线程），线程四（写线程），线程五线程六（读线程），然后再启动一个子线程来创建1K个读线程进行尝试写。
线程一先获取写锁，其它线程则进入对列阻塞等待，当线程一处理完毕释放锁的瞬间，如果中文的读线程二获取到读锁进行执行此时等待对列的头部是线程三，在三还没开始去读期间如果有非中文的读线程进行了读操作，则说明，这些读线程进行了插队。

package com.lvzb.lock;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 非公平的读写锁，写锁插队 和 读锁插队案例
 *
 * @author: lvzb31988
 * @date: 2023/02/03 17:16
 */
public class NofaireBargeDemoTest {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(false);
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    public void read() {
        System.out.println(Thread.currentThread().getName() + "尝试获取读锁");
        readLock.lock();
        try {
            TimeUnit.MILLISECONDS.sleep(20);
            System.out.println(Thread.currentThread().getName() + " 获取到了读锁...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }

    public void write() {
        System.out.println(Thread.currentThread().getName() + "尝试获取写锁");
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 获取到了写锁...");
            TimeUnit.MILLISECONDS.sleep(45);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + " 释放到了写锁...");
            writeLock.unlock();
        }
    }

    /**
     * 模拟读线程在队列头部是读线程时，新的读线程可以进行插队场景，
     * 大量的读线程需要在子线程里创建，主线程内创建模拟不出来
     *
     * @throws InterruptedException
     */
    @Test
    void nofairTest() throws InterruptedException {
        NofaireBargeDemoTest bargeDemo = new NofaireBargeDemoTest();

        List<Thread> arr = new ArrayList<>();
        new Thread(bargeDemo::write, "线程一").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程二").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程三").start();
        Thread.sleep(5);
        new Thread(bargeDemo::write, "线程四").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程五").start();
        Thread.sleep(5);
        new Thread(bargeDemo::read, "线程六").start();
        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                new Thread(bargeDemo::read, "线程" + i).start();
            }
        }).start();


        TimeUnit.SECONDS.sleep(50);
    }
}

参考执行结果

从结果可以看到很多数字类型的读线程在写线程一释放锁后，抢在了读线程二和线程三之前进行插队

线程一尝试获取写锁
线程一 获取到了写锁...
线程二尝试获取读锁
线程三尝试获取读锁
线程四尝试获取写锁
线程五尝试获取读锁
线程六尝试获取读锁
线程0尝试获取读锁
线程2尝试获取读锁
线程1尝试获取读锁
线程4尝试获取读锁
线程5尝试获取读锁
线程9尝试获取读锁
线程3尝试获取读锁
........
线程363尝试获取读锁
线程422尝试获取读锁
线程365尝试获取读锁
线程一 释放到了写锁...
线程428尝试获取读锁
线程426尝试获取读锁
线程320尝试获取读锁
线程369尝试获取读锁
线程432尝试获取读锁
线程427尝试获取读锁
线程421尝试获取读锁
线程366尝试获取读锁
线程412尝试获取读锁
线程431尝试获取读锁
线程413尝试获取读锁
线程398尝试获取读锁
线程430尝试获取读锁
线程395尝试获取读锁
线程396尝试获取读锁
线程367尝试获取读锁
线程424尝试获取读锁
线程335尝试获取读锁
线程392尝试获取读锁
线程364尝试获取读锁
线程370尝试获取读锁
线程424 获取到了读锁...
线程366 获取到了读锁...
线程431 获取到了读锁...
线程336尝试获取读锁
线程384尝试获取读锁
.......
线程433尝试获取读锁
线程421 获取到了读锁...
线程338尝试获取读锁
线程459尝试获取读锁
线程二 获取到了读锁...
线程369 获取到了读锁...
线程330尝试获取读锁
线程392 获取到了读锁...
线程427 获取到了读锁...
线程370 获取到了读锁...
线程372尝试获取读锁
线程320 获取到了读锁...
线程三 获取到了读锁...
线程364 获取到了读锁...
线程426 获取到了读锁...
线程432 获取到了读锁...
........

参考资料

LvQiFen
关注
专栏目录
并发编程-读写锁ReentrantReadWriteLock详解 & StampLock详解
weixin_43874650的博客
10-17 141
读写锁ReadWriteLock，顾名思义一把锁分为读与写两部分，读锁允许多个线程同时获得，因为读操作本身是线程安全的。而写锁是互斥锁，不允许多个线程同时获得写锁。并且读与写操作也是互斥的。读写锁适合多读少写的业务场景。针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它内部，维护了一对相关的锁，一个用于只读操作，称为读锁；一个用于写入操作，称为写锁，描述如下：1.没有其他线程的写锁2.没有写请求或者有写请求，但调用线程和持有锁的线程是同一个。
阿里面试失败后，一气之下我图解了Java中18把锁
热门推荐
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
读写锁ReentrantReadWriteLock案例
qq_40506747的博客
03-03 291
public class ReadWriteLock { public volatile Map<String,String> map = new HashMap<>(); ReentrantLock reentrantLock = new ReentrantLock(); ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(); //独占锁 public vo
简单案例--读写锁 ReentrantReadWriteLock
crazy的博客
09-03 212
1、 package multiThread.art; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class Cache { static Map<String , Object> map = new HashMap&
14 ReentrantReadWriteLock案例
weixin_39563769的博客
06-02 175
分别在不同的方法中给读，写分别加锁 class Count{ private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); //加读锁 public void get(){ rwl.readLock().lock();//其它线程只能读，不能写 try{ //业务操作 }catch(InterruptedeException e ){ //… }finally{ rwl.readLock.unLock();//释放锁 }..
ReentrantReadWriteLock 使用示例
小灰灰的博客
09-23 437
ReadWriteLock 使用示例 1.使用场景 前两天同事发给我一个工具类，封装了调用第三方接口的方法。 第三方接口调用需要带上访问凭据accessToken ，需要先调用login接口传入username password获取该token. 他在方法内部，每个业务请求之前都login获取新的accessToken ，我认为这样做不优雅，因为accessToken 不是一次性的，是有有效时间...
ReentrantReadWriteLock读写锁简单原理案例证明
duyabc的博客
01-31 7848
目录 ReentrantReadWriteLock存在原因？ 独占获取锁简单流程 共享获取锁简单流程 写锁降级 总结 ReentrantReadWriteLock存在原因？ 我们知道List的实现类ArrayList，LinkedList都是非线程安全的，Vector类通过用synchronized修饰方法保证了List的多线程非安全问题，但是有个缺点：读写同步，效率低下。于是就出现了CopyOnWriteArrayList，它通过写时复制数组实现了读写分离，提高了多线程对List读的效.
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
ReentrantReadWriteLock包含两种类型的锁：读锁（ReadLock）和写锁（WriteLock），它们可以独立地被获取和释放，从而提高了多线程环境下的并发性能。 1. **为什么需要ReentrantReadWriteLock？** - ...
Java并发编程之重入锁与读写锁
08-29
Java并发编程之重入锁与读写锁 在 Java 并发编程中，重入锁和读写锁是两个非常重要的概念。...重入锁和读写锁是 Java 并发编程中非常重要的概念，正确地使用它们可以提高并发性能，避免死锁和其他并发问题。
Java并发编程系列---可重入锁和读写锁的实现原理、源码分析
逆流而上的博客
02-11 1067
一、重入锁 1.1 什么是重入锁 重入锁ReentrantLock，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。 1.2 重入锁有什么用 例子：之前AQS的一个自己实现的锁 package com.example.demo.thread; import java.util.concurrent.TimeUnit; impor...
ReentrantReadWriteLock理解与实例
philos3的博客
04-18 904
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。 　　读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写
ReentrantLock核心源码分析
weixin_41590779的博客
08-17 193
ReentrantLock核心源码分析： ReentrantLock核心原理采用AQS原理实现。 ReentrantLock实现可重入锁核心原理： 公平锁与非公平锁的区别 所谓公平锁，即新加入的线程会按照尝试获取锁的先后顺序依次拿到锁。 所谓非公平锁，即新加入的线程会进行lock方法加锁进行CAS尝试，加锁失败之后tryAcquire方法state为0时候还会进行加锁尝试，而公平锁lock加锁不会尝试，tryAcquire方法state为0时候并且前面没有线程队列排队的时候才会进行加锁尝试。 Ree
java多线程（二五）ReentrantReadWriteLock读写锁详解（1）
maligebilaowang的博客
03-10 333
现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁，描述如下：线程进入读锁的前提条件：没有其他线程的写锁，
Java多线程之Lock的使用--重入锁(ReentrantLock)、Condition、公平锁和非公平锁、ReentrantReadWriteLock的使用（读写锁）
ChangWen的博客
08-27 2483
一、ReentrantLock的使用　　在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活。 　　 1、使用ReentrantLock实现同步 　　 既然ReentrantL
ReentrantReadWriteLock原理与使用
秃头的博客
01-08 1123
一、读写锁 有这样一种场景： 1、如果对一个共享资源的写操作没有读操作那么频繁，这个时候可以允许多个线程同时读取共享资源； 2、但是如果有一个线程想去写这些共享资源，那么其他线程此刻就不应该对这些资源进行读和写操作了。 Java中的ReentrantReadWriteLock正是为这种场景提供的锁。该类里面包括了读锁和写锁。 1.1、可获取读锁的情况 没有其他线程正在持有写锁； 尝试获取读锁的线程同时持有写锁。 1.2、可获取写锁的情况 没有其他线程正在持有读锁； 没有其他线程正在持有写锁。 1
Java-----ReentrantReadWriteLock的公平和非公平机制的实现
silently_frog的博客
09-12 1309
本篇记录ReentrantReadWriteLock公平锁和非公平锁的实现。 最开始看了些博客上面都提到了ReentrantReadWriteLock公平锁和非公平锁。于是自己想看看锁是长啥样的。最后看了半天，才明白他们说的锁不是我理解的真正存在的一个lock，而是一种机制,通过一些操作，实现了公平与非公平的机制.。 创建 实现类： 发现其实现类都重写了writerShouldBl...
通过java实现多个线程同时查询和更新库存信息场景
qq_41367365的博客
05-09 1126
在一个企业数据中台中，一个典型的线程锁业务场景是多个线程同时访问和更新共享资源。例如，一个企业可能有多个部门需要查询和更新库存信息。为了避免数据不一致和竞态条件，我们可以使用Java中的ReentrantReadWriteLock来保护共享数据。
通俗易懂读写锁ReentrantReadWriteLock的使用
m0_71777195的博客
10-17 5451
ReentrantReadWriteLock不知道大家熟悉吗？其实在实际的项目中用的比较少，反正我所在的项目没有用到过。ReentrantReadWriteLock称为读写锁，它提供一个读锁，支持多个线程共享同一把锁。它也提供了一把写锁，是独占锁，和其他读锁或者写锁互斥，表明只有一个线程能持有锁资源。通过两把锁的协同工作，能够最大化的提高读写的性能，特别是读多写少的场景，而往往大部分的场景都是读多写少的。本文主要讲解ReentrantReadWriteLock的使用和应用场景。
Java并发学习笔记：ReentrantReadWriteLock（良心长文(1)
最新发布
2401_84009597的博客
04-02 755
}复制代码非公平锁直接返回false，公平锁调用AQS里的判断当前线程是否有前驱节点。这是一个逻辑表达式的短路操作。如果是非公平锁，前一个条件返回false，那么要进行第二个条件的判断，尝试CAS设置锁；如果是公平锁，调用如果返回true，由于是操作，后一个条件不用判断了，这个逻辑表达式直接返回true，否则，才会走下一个条件。如果把改为就不行了。这个功能如果让我写，我肯定是if if if，源代码的作者巧妙利用短路的操作，精简了代码，水平确实高啊。public boolean tryLock() {ret
Java并发编程：读写锁ReentrantReadWriteLock与StampLock解析
"这篇资料主要介绍了Java并发编程中的读写锁ReentrantReadWriteLock以及相关的StampLock，强调了在读多写少的并发场景下，读写锁的优势。内容包括读写锁的基本概念、特性、使用方法，以及ReentrantReadWriteLock的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值