测试ReentrantReadWriteLock的相应特性

最新推荐文章于 2024-03-19 17:02:02 发布
最新推荐文章于 2024-03-19 17:02:02 发布
阅读量165 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42163781/article/details/105245879
版权

ReentrantReadWriteLock
所在的包是java.util.concurrent.locks.ReentrantReadWriteLock，读写锁所包含的锁有俩中，一种是与读操作相关的锁也被称为共享锁，一种是与写操作相关的锁也被称为排它锁，在没有写入操作时，读锁之间互不排斥，多个线程都可以获取读锁，当在涉及写入操作时，只有一个线程可以获取写锁进行写入操作，也就是说，当在读取时，多个线程可以同时获取读锁，当在写入式，只有一个线程可以写入。
互斥情况：读写互斥，写写互斥，写读互斥。
读锁：ReentrantReadWriteLock.readLock().lock(),
写锁：ReentrantReadWriteLock.writeLock().lock(),
读读共享的示例：

package com.example.demo.controller;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
测试ReentrantReadWriteLock的读读共享
 */
public class LockTest {
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                5,
                5,
                10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5));
        LOCKService lockService = new LOCKService();
        for(int i=0;i<3;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        lockService.read();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}
class LOCKService{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try {
            try {
                //设置写锁
                lock.readLock().lock();
                System.out.println("获得读锁"+"线程名为："+Thread.currentThread().getName()+"获取读锁时间为："+System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                //释放读锁
                System.out.println("释放读锁："+"线程名为："+Thread.currentThread().getName()+"获取读锁时间为："+System.currentTimeMillis());
                lock.readLock().unlock();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：在这里插入图片描述写写互斥示例：

package com.example.demo.controller;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
测试ReentrantReadWriteLock的写写互斥
 */
public class LockTest {
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                5,
                5,
                10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5));
        LOCKService lockService = new LOCKService();
        for(int i=0;i<3;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        lockService.write();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}
class LOCKService{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void write(){
        try {
            try {
                //设置写锁
                lock.writeLock().lock();
                System.out.println("获得写锁"+"线程名为："+Thread.currentThread().getName()+"获取写锁时间为："+System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                //释放读锁
                System.out.println("释放写锁："+"线程名为："+Thread.currentThread().getName()+"获取写锁时间为："+System.currentTimeMillis());
                lock.writeLock().unlock();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述读写互斥

package com.example.demo.controller;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
测试ReentrantReadWriteLock的读写互斥
 */
public class LockTest {
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                5,
                5,
                10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5));
        LOCKService lockService = new LOCKService();
        for(int i=0;i<3;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        lockService.read();
                        lockService.write();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}
class LOCKService{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    public void read(){
        try {
            try {
                //设置读锁
                lock.readLock().lock();
                System.out.println("获得读锁"+"线程名为："+Thread.currentThread().getName()+"获取读锁时间为："+System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
                System.out.println("释放读锁"+"线程名为："+Thread.currentThread().getName()+"释放读锁时间为："+System.currentTimeMillis());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public void write(){
        try {
            try {
                //设置写锁
                lock.writeLock().lock();
                System.out.println("获得写锁"+"线程名为："+Thread.currentThread().getName()+"获取写锁时间为："+System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                //释放写锁
                System.out.println("释放写锁："+"线程名为："+Thread.currentThread().getName()+"釋放写锁时间为："+System.currentTimeMillis());
                lock.writeLock().unlock();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果
在这里插入图片描述写读互斥：

package com.example.demo.controller;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
测试ReentrantReadWriteLock的写读互斥
 */
public class LockTest {
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                5,
                5,
                10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5));
        LOCKService lockService = new LOCKService();
        for(int i=0;i<3;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        lockService.write();
                        lockService.read();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}
class LOCKService{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    public void read(){
        try {
            try {
                //设置读锁
                lock.readLock().lock();
                System.out.println("获得读锁"+"线程名为："+Thread.currentThread().getName()+"获取读锁时间为："+System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
                System.out.println("释放读锁"+"线程名为："+Thread.currentThread().getName()+"释放读锁时间为："+System.currentTimeMillis());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public void write(){
        try {
            try {
                //设置写锁
                lock.writeLock().lock();
                System.out.println("获得写锁"+"线程名为："+Thread.currentThread().getName()+"获取写锁时间为："+System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                //释放写锁
                System.out.println("释放写锁："+"线程名为："+Thread.currentThread().getName()+"釋放写锁时间为："+System.currentTimeMillis());
                lock.writeLock().unlock();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述

进击的小白。。。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ReadWriteLock接口及其实现ReentrantReadWriteLock方法
08-30
ReadWriteLock 接口及其实现 ReentrantReadWriteLock 方法 在 Java 并发编程中，锁机制是非常重要的一种同步机制，用于解决多线程之间的资源竞争问题。在 Java 中，有多种锁机制，如 ReentrantLock、...
Java语言ReadWriteLock特性实例测试
08-28
【Java语言ReadWriteLock特性实例测试】 Java中的ReadWriteLock接口是Java并发包`java.util.concurrent.locks`中的一个重要组件，它提供了比单个锁更复杂的锁定机制。ReadWriteLock接口定义了两个锁：ReadLock（读...
通俗易懂读写锁ReentrantReadWriteLock的使用
m0_71777195的博客
10-17 5177
ReentrantReadWriteLock不知道大家熟悉吗？其实在实际的项目中用的比较少，反正我所在的项目没有用到过。ReentrantReadWriteLock称为读写锁，它提供一个读锁，支持多个线程共享同一把锁。它也提供了一把写锁，是独占锁，和其他读锁或者写锁互斥，表明只有一个线程能持有锁资源。通过两把锁的协同工作，能够最大化的提高读写的性能，特别是读多写少的场景，而往往大部分的场景都是读多写少的。本文主要讲解ReentrantReadWriteLock的使用和应用场景。
读写锁ReentrantReadWriteLock详解
CodePanda@GPF的博客
04-10 3450
读写锁、ReentrantReadWriteLock
ReentrantReadWriteLock读写锁
m0_56054652的博客
11-04 2056
一、前言 ReentrantReadWriteLock中包含三种锁：读写锁、可重入锁、公平/非公平锁 1、读写锁 2、可重入锁： 又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。 对于Java ReetrantLock而言，从名字就可以看出是一个重入锁，其名字是Re entrant Lock 重新进入锁。 对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。 syn...
并发编程之ReentrantReadWriteLock详解
尽力而为！
01-13 1362
ReentrantReadWriteLock是Java中的一个读写锁实现，它允许多个线程同时读取共享资源（读读可以并发），但在写入时只允许一个线程独占（读写，写读，写写互斥）。这个锁支持重入，即同一个线程可以多次获取相同类型的锁。这种锁可以提高读操作的并发性，同时保证写操作的独占性。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。线程进入读锁的前提条件没有其他线程的写锁没有写请求或者有写请求，但调用线程和持有锁的线程是同一个。
ReentrantReadWriteLock原理详解
m0_53127809的博客
12-02 3268
当读操作远远高于写操作时,这时候使用读写锁让读——读可以并发,提高性能。 类似于数据库中的select.,from..lockinsharemode 提供一个数据容器类内部分别使用读锁保护数据的read()方法,写锁保护数据的write()方法 简单来说，就是读锁可以共享，但是写锁必须独占 一、ReentrantReadWriteLock JUC为我们提供了一个可用于读和写的读写锁。 简单看下使用方法： ReentrantReadWriteLo...
Java多线程 ReentrantReadWriteLock原理及实例详解
08-25
- **可重入性**：与ReentrantLock类似，ReentrantReadWriteLock支持锁的可重入特性，即线程可以多次获取同一类型的锁（读锁或写锁），而不会被自己阻塞。 - **公平性**：ReentrantReadWriteLock可以设置为公平模式...
ReentrantReadWriteLock 源码解析
01-21
　针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁 类图如下： 说明：如上图所示Sync为ReentrantReadWriteLock...
ReentrantReadWriteLock.xmind
04-08
ReentrantReadWriteLock 读写锁除了保证写操作对读操作可见性以及并发行提升外，简化了读写交互场景开发
一文搞懂“ReentrantReadWriteLock——读写锁”
最新发布
lvhao123456789的博客
03-19 1519
一文搞懂“ReentrantReadWriteLock——读写锁”
ReentrantReadWriteLock详解
weixin_41951205的博客
02-28 789
一、简介 1. 什么是读写锁 前面我们介绍了ReentrantLock类，知道它的功能类似synchronized关键字，属于排它锁，同一时刻仅有一个线程可以进行访问。但是在大部分的场景下，读操作往往远大于写操作，其中读操作之前不存在数竞争关系，而写操作与其余的读写操作互斥。因此JDK为我们提供了读写锁——ReentrantReadWriteLock。 读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时
【并发编程学习篇】ReentrantReadWriteLock详解
热门推荐
一个勤勤恳恳的程序猿
11-23 2万+
现实中有这样一种场景对共享资源有读和写的操作，且写操作没有读操作那么频繁（读多写少）在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源（读读可以并发）但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写操作了（读写，写读，写写互斥）在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。
Java并发包中的读写锁及其实现分析
极北三少
11-02 575
1. 前言 在Java并发包中常用的锁（如：ReentrantLock），基本上都是排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。 除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁
十、详解ReentrantReadWriteLock读写锁
2301_77203215的博客
12-28 887
之前我们讲过可重入锁从这篇博文中我们可以了解到，基于lock的锁底层都是利用aqs这个抽象类的。那么在读写锁中，其本质也是利用aqs，与可重入锁之间的区别的就是在实现抽象方法的时候，具体的逻辑不一样。可以理解为两者骨架一样，但是具体细节逻辑有区别，尤其是在tryAcquire和tryRelease的逻辑不一样。
java read write lock_Java并发编程--ReentrantReadWriteLock
weixin_42279320的博客
02-17 181
概述ReentrantReadWriteLock是Lock的另一种实现方式，我们已经知道了ReentrantLock是一个排他锁，同一时间只允许一个线程访问，而ReentrantReadWriteLock允许多个读线程同时访问，但不允许写线程和读线程、写线程和写线程同时访问。相对于排他锁，提高了并发性。在实际应用中，大部分情况下对共享数据(如缓存)的访问都是读操作远多于写操作，这时Reentran...
读写锁ReentrantReadWriteLock的原理
andy的博客
01-09 993
解决线程安全问题使用ReentrantLock就可以，但是ReentrantLock是独占锁，某时只有一个线程可以获取该锁，而实际中会有写少读多的场景，显然ReentrantLock满足不了这个需求，所以ReentrantReadWriteLock应运而生。ReentrantReadWriteLock采用读写分离的策略，允许多个线程可以同时获取读锁。
ReentrantReadWriteLock
05-28
ReReadWriteLock是一个Java中的锁...ReentrantReadWriteLock实现了可重入锁的功能，因此允许同一个线程重复获取锁。这种锁的使用可以提高多线程程序的性能，因为多个线程可以同时读取相同的共享资源，而不会发生冲突。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值