13、ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

最新推荐文章于 2022-11-09 22:27:51 发布
最新推荐文章于 2022-11-09 22:27:51 发布
阅读量537 收藏 1
点赞数 1
分类专栏： 多线程 文章标签： java juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyangel2013/article/details/125216719
版权

1、一些面试题

无锁→独占锁→读写锁→邮戳锁

你知道Java里面有哪些锁?

你说你用过读写锁，锁饥饿问题是什么？

有没有比读写锁更快的锁？

StampedLock知道吗?(邮戳锁/票据锁)

ReentrantReadWriteLock有锁降级机制策略你知道吗？

2、请你简单聊聊ReentrantReadWriteLock

2.1、是什么

读写锁定义为

一个资源能够被 多个读线程 访问，或者被 一个写线程 访问，但是不能同时存在读写线程。 

『读写锁』意义和特点

『 读写锁 ReentrantReadWriteLock 』 并不是 真正意义上的读写分离， 它只允许读读共存，而读写和写写依然是互斥的， 

大多实际场景是 “读/读”线程间并不存在互斥关系 ，只有"读/写"线程或"写/写"线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。 

   

一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁( 切菜还是拍蒜选一个 )。 

也即 一个资源可以被多个读操作访问或一个写操作访问 ，但两者不能同时进行。 

  

只有在读多写少情境之下，读写锁才具有较高的性能体现。 

2.2、特点

可重入、读写分离

无锁无序→加锁→读写锁演变复习

package com.atguigu.juc.rwlock;





import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;



class MyResource

{

    Map<String,String> map = new HashMap<>();

    //=====ReentrantLock 等价于 =====synchronized

    Lock lock = new ReentrantLock();

    //=====ReentrantReadWriteLock 一体两面，读写互斥，读读共享

    ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();



    public void write(String key,String value)

    {

        rwLock.writeLock().lock();

        try

        {

            System.out.println(Thread.currentThread().getName()+"\t"+"---正在写入");

            map.put(key,value);

            try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }

            System.out.println(Thread.currentThread().getName()+"\t"+"---完成写入");

        }finally {

            rwLock.writeLock().unlock();

        }

    }



    public void read(String key)

    {

        rwLock.readLock().lock();

        try

        {

            System.out.println(Thread.currentThread().getName()+"\t"+"---正在读取");

            String result = map.get(key);

            //暂停几秒钟线程

            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

            System.out.println(Thread.currentThread().getName()+"\t"+"---完成读取result： "+result);

        }finally {

            rwLock.readLock().unlock();

        }

    }



}









/**

 * @auther zzyy

 * @create 2021-03-28 11:04

 */

public class ReentrantReadWriteLockDemo

{

    public static void main(String[] args)

    {

        MyResource myResource = new MyResource();



        for (int i = 1; i <=10; i++) {

            int finalI = i;

            new Thread(() -> {

                myResource.write(finalI +"", finalI +"");

            },String.valueOf(i)).start();

        }



        for (int i = 1; i <=10; i++) {

            int finalI = i;

            new Thread(() -> {

                myResource.read(finalI +"");

            },String.valueOf(i)).start();

        }

         // 暂停几秒钟线程

        try { TimeUnit. SECONDS .sleep( 1 ); } catch (InterruptedException e) { e.printStackTrace(); }



        for (int i = 1; i <=3; i++) {

            int finalI = i;

            new Thread(() -> {

                myResource.write(finalI +"", finalI +"");

            },"施小赞"+String.valueOf(i)).start();

        }



    }

}

运行结果：

1---正在写入

1---完成写入

3---正在写入

3---完成写入

2---正在写入

2---完成写入

4---正在写入

4---完成写入

5---正在写入

5---完成写入

6---正在写入

6---完成写入

7---正在写入

7---完成写入

8---正在写入

8---完成写入

9---正在写入

9---完成写入

10---正在写入

10---完成写入

1---正在读取

2---正在读取

3---正在读取

4---正在读取

6---正在读取

5---正在读取

8---正在读取

9---正在读取

7---正在读取

10---正在读取

3---完成读取result： 3

7---完成读取result： 7

10---完成读取result： 10

4---完成读取result： 4

9---完成读取result： 9

6---完成读取result： 6

5---完成读取result： 5

1---完成读取result： 1

8---完成读取result： 8

2---完成读取result： 2

施小赞1---正在写入

施小赞1---完成写入

施小赞2---正在写入

施小赞2---完成写入

施小赞3---正在写入

施小赞3---完成写入

从写锁→读锁，ReentrantReadWriteLock可以降级

《Java 并发编程的艺术》中关于锁降级的说明：

 

why锁降级？？？ 

见后面《Oracle 公司 ReentrantWriteReadLock 源码总结 》 

大白话：

锁降级：将写入锁降级为读锁(类似Linux文件读写权限理解，就像写权限要高于读权限一样)

读写锁降级演示

锁降级：遵循获取写锁→再获取读锁→再释放写锁的次序，写锁能够降级成为读锁。 

如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。 

 

重入还允许通过获取写入锁定，然后读取锁然后释放写锁从写锁到读取锁,  

但是，从读锁定升级到写锁是不可能的。 

锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性

锁降级 

package com.atguigu.juc.rwlock;



import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.ReentrantReadWriteLock;



/**

 * @auther zzyy

 * @create 2021-03-28 10:18

 * 锁降级：遵循获取写锁→再获取读锁→再释放写锁的次序，写锁能够降级成为读锁。

 * <p>

 * 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。

 */

public class LockDownGradingDemoCopy1 {

    public static void main(String[] args) {

        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();

        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

        writeLock.lock();

        System.out.println("------- 正在写入 ");

        readLock.lock();

        System.out.println("------- 正在读取 ");



        writeLock.unlock();





    }

}

 

不能锁升级

package com.atguigu.juc.rwlock;



import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.ReentrantReadWriteLock;



/**

 * @auther zzyy

 * @create 2021-03-28 10:18

 * 锁降级：遵循获取写锁→再获取读锁→再释放写锁的次序，写锁能够降级成为读锁。

 * <p>

 * 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。

 */

public class LockDownGradingDemoCopy1 {

    public static void main(String[] args) {

        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();

        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

        readLock.lock();

        System.out.println("------- 正在读取 ");

        writeLock.lock();

        System.out.println("------- 正在写入 ");

        writeLock.unlock();





    }

}

 

如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略

线程获取读锁是 不能 直接升级为写入锁的。 

 

 

在ReentrantReadWriteLock中，当读锁被使用时，如果有线程尝试获取写锁，该写线程会被阻塞。 

所以，需要释放所有读锁，才可获取写锁， 

 

写锁和读锁是互斥的  

写锁和读锁是互斥的 （这里的互斥是指 线程间的互斥 ， 当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要 保持写操作的可见性 。 

因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。 

因此， 

分析读写锁ReentrantReadWriteLock ，会发现它有个潜在的问题： 

读锁全完，写锁有望；写锁独占，读写全堵； 

如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，见前面Case《code演示LockDownGradingDemo》 

即ReadWriteLock 读的过程中不允许写 ， 只有等待线程都释放了读锁，当前线程才能获取 写锁 ， 

也就是写入必须等待 ， 这是一种 悲观的读锁 ，o(╥﹏╥)o，人家还在读着那，你先别去写，省的数据乱。 

================================后续讲解StampedLock时再详细展开======================= 

分析StampedLock(后面详细讲解) ，会发现它改进之处在于： 

读的过程中也允许获取写锁介入(相当牛B，读和写两个操作也让你“共享”(注意引号)) ，这样会导致我们读的数据就可能不一致！ 

所以，需要额外的方法来判断 读的过程中是否有写入， 这是一种 乐观的读锁 ，O(∩_∩)O哈哈~。   

显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。 

读写锁之读写规矩，再说降级 Oracle公司ReentrantWriteReadLock源码总结

锁降级   下面的示例代码摘自ReentrantWriteReadLock源码中： 

ReentrantWriteReadLock支持锁降级，遵循按照获取写锁，获取读锁再释放写锁的次序， 写锁能够降级成为读锁 ，不支持锁升级。 

解读在最下面: 

 

1 代码中声明了一个volatile类型的cacheValid变量，保证其可见性。

2 首先获取读锁，如果cache不可用，则释放读锁，获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前获取读锁；此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性。 

  

如果违背锁降级的步骤   

如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程D获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。 

  

如果遵循锁降级的步骤  

线程C在释放写锁之前获取读锁，那么线程D在获取写锁时将被阻塞，直到线程C完成数据处理过程，释放读锁。这样可以保证返回的数据是这次更新的数据，该机制是专门为了缓存设计的。 

3、面试题：有没有比读写锁更快的锁？邮戳锁StampedLock

3.1、是什么

StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化。

邮戳锁也叫票据锁

stamp（戳记，long类型）代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。

3.2、它是由锁饥饿问题引出

3.2.1、锁饥饿问题

ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了， 

假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了  

因为当前有可能会一直存在读锁，而无法获得写锁， 根本没机会写，o(╥﹏╥)o 

3.2.2、如何缓解锁饥饿问题？

使用“公平”策略可以一定程度上缓解这个问题   new ReentrantReadWriteLock(true);

但是“公平”策略是以牺牲系统吞吐量为代价的

3.2.3、StampedLock类的乐观读锁闪亮登场 

ReentrantReadWriteLock 

允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态， 读锁和写锁也是互斥的，所以在读的时候是不允许写的，读写锁比传统的synchronized速度要快很多， 原因就是在于 ReentrantReadWriteLock 支持 读并发 

  

 StampedLock横空出世 

ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。 

但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时 不会被阻塞 ，这其实是对读锁的优化， 

所以， 在获取乐观读锁后，还需要对结果进行校验。 

3.3、StampedLock的特点

所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为零表示获取失败，其余都表示成功；

所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；

StampedLock是不可重入的，危险(如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁)

StampedLock有三种访问模式

①Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似

②Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似

③Optimistic reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式

乐观读模式code演示 读的过程中也允许获取写锁介入

package com.atguigu.juc.rwlock;



import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.StampedLock;



/**

 * @auther zzyy

 * @create 2021-03-29 11:35

 */

public class StampedLockDemo

{

    static int number = 37;

    static StampedLock stampedLock = new StampedLock();



    public void write()

    {

        long stamp = stampedLock.writeLock();

        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程准备修改");

        try

        {

            number = number + 13;

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            stampedLock.unlockWrite(stamp);

        }

        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");

    }



    //悲观读

    public void read()

    {

        long stamp = stampedLock.readLock();

        System.out.println(Thread.currentThread().getName()+"\t come in readlock block,4 seconds continue...");

        //暂停4秒钟线程

        for (int i = 0; i <4 ; i++) {

            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......");

        }

        try

        {

            int result = number;

            System.out.println(Thread.currentThread().getName()+"\t"+" 获得成员变量值result：" + result);

            System.out.println("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            stampedLock.unlockRead(stamp);

        }

    }



    //乐观读

    public void tryOptimisticRead()

    {

        long stamp = stampedLock.tryOptimisticRead();

        //先把数据取得一次

        int result = number;

        //间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，愿望美好，实际情况靠判断。

        System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)"+"\t"+stampedLock.validate(stamp));

        for (int i = 1; i <=4 ; i++) {

            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......"+i+

                    "秒后stampedLock.validate值(true无修改，false有修改)"+"\t"

                    +stampedLock.validate(stamp));

        }

        if(!stampedLock.validate(stamp)) {

            System.out.println("有人动过--------存在写操作！");

            //有人动过了，需要从乐观读切换到普通读的模式。

            stamp = stampedLock.readLock();

            try {

                System.out.println("从乐观读 升级为 悲观读并重新获取数据");

                //重新获取数据

                result = number;

                System.out.println("重新悲观读锁通过获取到的成员变量值result：" + result);

            }catch (Exception e){

                e.printStackTrace();

            }finally {

                stampedLock.unlockRead(stamp);

            }

        }

        System.out.println(Thread.currentThread().getName()+"\t finally value: "+result);

    }



    public static void main(String[] args)

    {

        StampedLockDemo resource = new StampedLockDemo();



        //1 悲观读,和ReentrantReadWriteLock一样

        /*new Thread(() -> {

            //悲观读

            resource.read();

        },"readThread").start();*/



        //2 乐观读，成功

        /*new Thread(() -> {

            //乐观读

            resource.tryOptimisticRead();

        },"readThread").start();



        //6秒钟乐观读取resource.tryOptimisticRead()成功

        try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }*/



        //3 乐观读，失败，重新转为悲观读，重读数据一次

        new Thread(() -> {

            //乐观读

            resource.tryOptimisticRead();

        },"readThread").start();



        //2秒钟乐观读取resource.tryOptimisticRead()失败

        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }





        new Thread(() -> {

            resource.write();

        },"writeThread").start();



    }

}

3.4、StampedLock的缺点

StampedLock 不支持重入，没有Re开头

StampedLock 的悲观读锁和写锁都不支持条件变量（Condition），这个也需要注意。

使用 StampedLock一定不要调用中断操作，即不要调用interrupt() 方法

如果需要支持中断功能，一定使用可中断的悲观读锁 readLockInterruptibly()和写锁writeLockInterruptibly()

  

施小赞
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JUC知识点总结（三）ReentrantLock与ReentrantReadWriteLock源码解析
01-21
8. Lock接口 （ReentrantLock 可重入锁） 特性 ReentantLock 继承接口 Lock 并实现了接口中定义的方法， 它是一种可重入锁， 除了能完成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁...
多线程进阶学习06------ReentrantLock、ReentrantReadWriteLock、StampedLock详解
四维大脑的博客
03-22 444
无锁->独占锁->读写锁->邮戳锁
13、ReentrantLock、ReentrantReadWriteLock、StampedLock
PingFanXianSheng的博客
08-30 347
ReentrantLock、ReentrantReadWriteLock、StampedLock这三个锁的关系，以及后两个锁由来的原因；从API使用层面，通俗易懂的讲解了这几个锁的区别与相同。
2019.11.14学习总结
qq_41641761的博客
11-15 312
Java开发中几种常见的锁 1.公平锁 是指多个线程按照申请锁的顺序来获取资源，类似于队列，先进先出（FIFO）。 2.非公平锁 是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程先获得锁。在高并发的情况下，有可能造成优先级反转或饥饿现象。 源码： public ReentrantLock(boolean fair) { sync = fair ? new F...
ReentrantReadWriteLock、StampedLock说明
qq_45996900的博客
10-30 425
1 代码中声明了一个volatile类型的cacheValid变量，保证其可见性。2 首先获取读锁，如果cache不可用，则释放读锁。获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前立刻抢夺获取读锁;此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性。总结:一句话，同一个线程自己持有写锁时再去拿读锁，其本质相当于重入。
ReentrantLock和ReentrantReadWriteLock类的使用
forever-and-ever的博客
08-24 608
在Java中，可以使用synchronized关键字实现线程之间同步互斥，除此以外，JDK中的Lock对象也能实现同步的效果，而且在使用上更加方便灵活，扩展功能也更加强大。常用的两个Lock类为ReentrantLock和ReentrantReadWriteLock。 ReentrantLock类在功能上相比synchronized关键字更多。 下面先介绍一下ReentrantLock类的使用...
contention-profiling:ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
06-10
争用分析 ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
ReentrantLock实现原理详解
08-31
本文将对ReentrantLock实现原理进行详细的介绍，具有很好的参考价值，下面跟着小编一起来看下吧
ReentrantLock.java
02-24
ReentrantLock.java
java ReentrantLock详解
08-26
主要介绍了java ReentrantLock，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
JAVA中的ReentrantLock和ReentrantReadWriteLock锁简单使用
madman
01-20 7159
ReentrantLock的作用和synchronize是一样的，都是实现锁的功能，但是ReentrantLock需要手写代码对锁进行获取和释放(一定要在finally里面释放)，要不然就永远死锁了，ReentrantLock也可以用来做线程之间的挂起和通知，synchronize一般是使用object的wait和notify来实现，ReentrantLock使用Condition来实现线程之间的...
（四）Lock，ReentrantLock，ReentrantReadWriteLock类的使用以及相关api---synchronized进阶...
_Ennio
08-21 134
这篇博客记录了Lock，ReentrantLock,ReentrantReadWriteLock类的使用以及其一些api： 码字不易~~另外《java多线程编程核心技术》这本书读着很爽 前言说明：之前为了解决多线程时的非线程安全问题，使用的是synchronized。接下来记录的是他的升级版本ReentrantLock，更加灵活，可控性更高，而ReentrantReadWriteLock类是对...
读写锁 ReadWriteLock 适用场景
wujian_csdn_csdn的博客
03-05 3333
前言 在没有读写锁之前，ReentrantLock 虽然可以保证了线程安全，但是也浪费了一定的资源，因为如果多个读操作同时进行，其实并没有线程安全问题，我们可以允许让多个读操作并行，以便提高程序效率。 但是写操作不是线程安全的，如果多个线程同时写，或者在写的同时进行读操作，便会造成线程安全问题。 我们的读写锁就解决了这样的问题，它设定了一套规则，既可以保证多个线程同时读的效率，同时又可以保证有写入操作时的线程安全。 整体思路是它有两把锁，第 1 把锁是写锁，获得写锁之后，既可以读数据又可以修改数据，而第 2
ReentrantLock和ReentrantReadWriteLock使用介绍
JackCaptain1015的博客
05-22 475
ReentrantLock、ReentrantReadWrietLock
ReentrantReadWriteLock死锁分析
成名宁杰的博客
05-31 808
ReentrantReadWriteLock死锁分析：1、锁升级；2、Stack Overflow
线程死锁
08-28 172
原创转载请注明出处：https://www.cnblogs.com/agilestyle/p/11424647.html 死锁：一组互相竞争资源的线程因互相等待，导致“永久”阻塞的现象。 解决死锁，要么重启，要么规避 那如何避免死锁呢？要避免死锁就需要分析死锁发生的条件，只有以下这四个条件都发生时才会出现死锁： 互斥，共享资源 X 和 Y 只能被一个线程占用； 占有...
ReentrantLock、ReentrantReadWriteLock、StampedLock
qq_44300280的博客
11-09 1074
ReentrantLock、ReentrantReadWriteLock、StampedLock
理解Java并发编程：ReentrantLock和ReentrantReadWriteLock
鸟哥哥的专栏
11-03 530
基于AQS的ReentrantLock和ReentrantReadWriteLock，java并发编程
读写锁——ReentrantReadWriteLock
weixin_52383177的博客
09-20 318
排他锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁能够简化读写交互场景的编程方式。假设在程序中定义一个共享的用作缓存数据结构，它大部分时间提供读服务（例如查询和搜索），而写操作占有的时间很少，但是写操作完成之后的更新需要对后续的读服务可见。
ReentrantLock， ReentrantReadWriteLock
最新发布
07-27
ReentrantLock和ReentrantReadWriteLock是Java中用于线程同步的锁机制。 ReentrantLock是一个可重入的互斥锁，也就是说同一个线程可以多次获得该锁。它提供了与synchronized关键字类似的功能，但是具有更灵活的控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值