ReadWriteLock读写锁

最新推荐文章于 2024-08-17 10:11:38 发布
最新推荐文章于 2024-08-17 10:11:38 发布
阅读量215 收藏
点赞数
分类专栏： java 文章标签： ReadWriteLock ExecutorService Future BigDecimal Callable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shy415502155/article/details/88836055
版权

ReadWriteLock管理一组锁，一个是只读的锁，一个是写锁。读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
所有读写锁的实现必须确保写操作对读操作的内存影响。

非公平模式（默认）
当以非公平初始化时，读锁和写锁的获取的顺序是不确定的。非公平锁主张竞争获取，可能会延缓一个或多个读或写线程，但是会比公平锁有更高的吞吐量。
公平模式
当以公平模式初始化时，线程将会以队列的顺序获取锁。当当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。
当有写线程持有写锁或者有等待的写线程时，一个尝试获取公平的读锁（非重入）的线程就会阻塞。这个线程直到等待时间最长的写锁获得锁后并释放掉锁后才能获取到读锁。

公平锁和非公平锁的区别

公平锁：当线程发现已经有线程在排对获取锁了，那么它必须排队，除了一种情况就是，线程已经占有锁，此次是重入，不用排队。

非公平锁：只有一种情况需排队，其他情况不用排队就可以尝试获取锁： 如果当前全局处于读锁状态，且等待队列中第一个等待线程想获取写锁，那么当前线程能够获取到读锁的条件为：当前线程获取了写锁，还未释放；当前线程获取了读锁，这一次只是重入读锁而已；其它情况当前线程入队尾。

模拟一个列子，多个人同时操作一个银行账户查询或者存取操作

1.账号

public class MyCount {
	
	private String cardNumber;//卡号
	
	private BigDecimal balance;//余额
	
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "MyCount [cardNumber=" + cardNumber + ", balance=" + balance + "]";
	}

	/**
	 * @return the cardNumber
	 */
	public String getCardNumber() {
		return cardNumber;
	}

	/**
	 * @param cardNumber the cardNumber to set
	 */
	public void setCardNumber(String cardNumber) {
		this.cardNumber = cardNumber;
	}

	/**
	 * @return the balance
	 */
	public BigDecimal getBalance() {
		return balance;
	}

	/**
	 * @param balance the balance to set
	 */
	public void setBalance(BigDecimal balance) {
		this.balance = balance;
	}
}

2. 用户查询和存取钱操作

@Slf4j
public class BankTask implements Callable {
	
	 private String name;            //用户名
     private MyCount myCount;        //所要操作的账户
     private BigDecimal cash;        //操作的金额
     private ReadWriteLock myLock;   //执行操作所需的锁对象
     private boolean ischeck;        //是否查询

	public BankTask(String name, MyCount myCount, BigDecimal cash, ReadWriteLock myLock, boolean ischeck) {
		super();
		this.name = name;
		this.myCount = myCount;
		this.cash = cash;
		this.myLock = myLock;
		this.ischeck = ischeck;
	}

	@Override
	public Object call() throws Exception {
		Map<String, Object> map = new HashMap<String, Object>();
		if (ischeck) {
			myLock.readLock().lock();
			log.info("用户" + name + "正在查询" + myCount + "账户，当前金额为 :" + myCount.getBalance());
			myLock.readLock().unlock();
		} else {
			myLock.writeLock().lock();
			log.info("用户操作前卡中信息 ：" + name + "正在查询" + myCount + "账户，当前金额为 :" + myCount.getBalance());
			String balance = myCount.getBalance().toString();
			//假如为取钱业务，需要判断当前账户余额是否充足
			BigDecimal drawMoney = myCount.getBalance().add(cash);
			int compare = drawMoney.compareTo(BigDecimal.ZERO);
			if (compare == Constant.NEGATIVE) {//余额不足
				map.put("CODE", Constant.NEGATIVE);
				map.put("MSG", "FAIL : not sufficient funds .");
				map.put("SUCCESS", false);
			} else {
				myCount.setBalance(myCount.getBalance().add(cash));
				log.info("操作银行卡(存钱/取钱) ：￥" + cash + "元   , 操作前余额为 ：$" + balance + "元   ," + name + "正在查询" + myCount + "账户，当前金额为 :" + myCount.getBalance());
				myLock.writeLock().unlock();
				map.put("CODE", 0);
				map.put("MSG", "SUCCESS");
				map.put("SUCCESS", true);
			}
		}
		
		return map;
	}

}

3. 模拟多用户操作

@Slf4j
public class ReentrantReadWriteLockTest {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		MyCount myCount = new MyCount();
		myCount.setBalance(new BigDecimal(10000));//账户余额
		myCount.setCardNumber("100086110120119");
		
		 ReadWriteLock lock = new ReentrantReadWriteLock(false);//查询余额参数为true  存取操作参数为false
		 
		 ExecutorService pool = Executors.newCachedThreadPool();
		 String[] name = {"张三","张三的父亲","张三的母亲","张三的大儿子","张三的二儿子","张三的三儿子","张三的四儿子","张三的五儿子","张三的六儿子","张三的七儿子"};
		 String[] operateBalance = {"-20000","8000","-1000","500","500","-1000","1000","2000","3000","-10000"};
		 
		 for (int i = 0; i < name.length; i++) {
			BankTask bankTask = new BankTask(name[i], myCount, new BigDecimal(operateBalance[i]), lock, false);
			Future future = pool.submit(bankTask);
			Map<String, Object> returnMap = (Map<String, Object>) future.get();
			log.info("Thread " + i + ": " + name[i] + "操作结果  result : { CODE :" + returnMap.get("CODE") + " MSG :" + returnMap.get("MSG") + " SUCCESS :" + returnMap.get("SUCCESS"));
		}
		 pool.shutdown();
	}
}

输出结果：

- 用户操作前卡中信息 ：张三正在查询MyCount [cardNumber=100086110120119, balance=10000]账户，当前金额为 :10000
- Thread 0: 张三操作结果  result : { CODE :-1 MSG :FAIL : not sufficient funds . SUCCESS :false
- 用户操作前卡中信息 ：张三的父亲正在查询MyCount [cardNumber=100086110120119, balance=10000]账户，当前金额为 :10000
- 操作银行卡(存钱/取钱) ：￥8000元   , 操作前余额为 ：$10000元   ,张三的父亲正在查询MyCount [cardNumber=100086110120119, balance=18000]账户，当前金额为 :18000
- Thread 1: 张三的父亲操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的母亲正在查询MyCount [cardNumber=100086110120119, balance=18000]账户，当前金额为 :18000
- 操作银行卡(存钱/取钱) ：￥-1000元   , 操作前余额为 ：$18000元   ,张三的母亲正在查询MyCount [cardNumber=100086110120119, balance=17000]账户，当前金额为 :17000
- Thread 2: 张三的母亲操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的大儿子正在查询MyCount [cardNumber=100086110120119, balance=17000]账户，当前金额为 :17000
- 操作银行卡(存钱/取钱) ：￥500元   , 操作前余额为 ：$17000元   ,张三的大儿子正在查询MyCount [cardNumber=100086110120119, balance=17500]账户，当前金额为 :17500
- Thread 3: 张三的大儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的二儿子正在查询MyCount [cardNumber=100086110120119, balance=17500]账户，当前金额为 :17500
- 操作银行卡(存钱/取钱) ：￥500元   , 操作前余额为 ：$17500元   ,张三的二儿子正在查询MyCount [cardNumber=100086110120119, balance=18000]账户，当前金额为 :18000
- Thread 4: 张三的二儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的三儿子正在查询MyCount [cardNumber=100086110120119, balance=18000]账户，当前金额为 :18000
- 操作银行卡(存钱/取钱) ：￥-1000元   , 操作前余额为 ：$18000元   ,张三的三儿子正在查询MyCount [cardNumber=100086110120119, balance=17000]账户，当前金额为 :17000
- Thread 5: 张三的三儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的四儿子正在查询MyCount [cardNumber=100086110120119, balance=17000]账户，当前金额为 :17000
- 操作银行卡(存钱/取钱) ：￥1000元   , 操作前余额为 ：$17000元   ,张三的四儿子正在查询MyCount [cardNumber=100086110120119, balance=18000]账户，当前金额为 :18000
- Thread 6: 张三的四儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的五儿子正在查询MyCount [cardNumber=100086110120119, balance=18000]账户，当前金额为 :18000
- 操作银行卡(存钱/取钱) ：￥2000元   , 操作前余额为 ：$18000元   ,张三的五儿子正在查询MyCount [cardNumber=100086110120119, balance=20000]账户，当前金额为 :20000
- Thread 7: 张三的五儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的六儿子正在查询MyCount [cardNumber=100086110120119, balance=20000]账户，当前金额为 :20000
- 操作银行卡(存钱/取钱) ：￥3000元   , 操作前余额为 ：$20000元   ,张三的六儿子正在查询MyCount [cardNumber=100086110120119, balance=23000]账户，当前金额为 :23000
- Thread 8: 张三的六儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true
- 用户操作前卡中信息 ：张三的七儿子正在查询MyCount [cardNumber=100086110120119, balance=23000]账户，当前金额为 :23000
- 操作银行卡(存钱/取钱) ：￥-10000元   , 操作前余额为 ：$23000元   ,张三的七儿子正在查询MyCount [cardNumber=100086110120119, balance=13000]账户，当前金额为 :13000
- Thread 9: 张三的七儿子操作结果  result : { CODE :0 MSG :SUCCESS SUCCESS :true

 

莫尼山
关注
专栏目录
Qt系列文章之三十二 (基于QThread的QReadWriteLock和QWaitCondition 的线程同步)
波风水门
07-12 368
前言 上一页讲解了QMutex的同步使用，今天本节将讲解 QReadWriteLock和QWaitCondition 线程同步的使用以及相关概念知识 QReadWriteLock使用 上文使用互斥量时存在一个问题: 每次只能有一个线程获得互斥量的权限。如果在一个程序中有多个线程读取某个变量，使用互斥量时也必须排队。而实际上若只是读取一个变量，是可以让多个线程同时访问的，这样互斥量就会降低程序的性能。 假设有一个数据采集程序，一个线程负责采集数据到缓冲区，一个线程负责读取缓冲区的数据并显示，另一个线程负责读取
ReadWriteLock读写锁简介、使用场景分析以及锁降级
d303577562的博客
09-11 1247
what 像ReentrantLock，Synchronized关键字，Mutex都是排它锁，这些锁在同一时刻只允许一个线程访问，而读写锁在同一时刻可以允许多个读线程访问，但是写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性能相对于一般的排它锁有了很大提升。 除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁能够简化读写交互场景的编程方式。假设在程序中定义一个共享的用作缓存的数据结构。它大部分时间都是提供读服务，例如查询和搜索，而
并发JUC之读写锁
IT二叔的博客
11-11 199
@Author: CYW @Date: 2020/11/11 20:07 List线程安全 并发下ArrayList是线程不安全的 解决办法 方法一1.将List list = new ArrayList<>(); 换成List list = new Vector<>();底层加了synchronized 方法二2.换成List list = Collections.synchronizedList(new ArrayList<>());底层加了synch.
Java并发编程 - 读写锁ReadWriteLock详解
最新发布
qq_33240556的博客
08-17 521
读写锁是一种非常有效的同步机制，尤其适用于读取操作远多于写入操作的场景。通过允许多个读取者同时访问共享资源，可以显著提高并发性能。提供了丰富的功能，包括升级和降级锁的能力，使得它成为一个强大且灵活的工具。在实际应用中，合理选择锁的类型和管理锁的使用可以大大提高程序的性能和可维护性。
Java中的读/写锁
weixin_33881140的博客
05-22 184
相比Java中的锁(Locks in Java)里 Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一 个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说...
ReadWriteLock（读写锁）
热门推荐
Student111w的博客
07-18 2万+
ReadWriteLock ReadWriteLock也是一个接口，提供了readLock和writeLock两种锁的操作机制，一个资源可以被多个线程同时读，或者被一个线程写，但是不能同时存在读和写线程。 读锁：共享锁 readLock **写锁：**独占锁 writeLock 读写锁 ： 一个资源可以被多个读的线程进行访问 ，或者可以被一个写的线程访问， 但是不能同时存在读和写进程 ，读写互斥，读读共享。 读的时候可以多个线程一起读 写的时候只能一个线程写 使用示例： 向map中添加和读取值 p
Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁
09-03
- **读写锁**: 除了ReentrantLock，Java还提供了ReadWriteLock接口，它包含两个Lock对象：一个用于读操作（ReadLock），允许多个线程同时读取共享资源；另一个用于写操作（WriteLock），一次只允许一个线程写入。...
Redisson 源码初探（九）ReadWriteLock 读写锁
wangxuelei036的博客
02-27 1283
读写锁得概念我们就不再赘述了 public static void main(String[] args) throws Exception { //构建一个配置信息对象 Config config = new Config(); config.useClusterServers() //定时扫描连接信息 默认1000ms .setScanInterval(2000)
ReadWriteLock读写之间互斥吗？（详解）
qq_59837950的博客
11-05 335
ReadWriteLock读写锁之间的共享互斥问题，一目了然！
JUC学习笔记 -- (9) ReadWriteLock读写锁的使用
YellowStar的博客
10-24 731
  说到Java并发编程，很多开发第一个想到同时也是经常常用的肯定是Synchronized，但是Synchronized存在明显的一个性能问题就是读与读之间互斥，简言之就是，我们编程想要实现的最好效果是，可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写的效率，这就要用到本章的重点ReadWriteLock读写锁。 之前文章已经介绍了Lock的一种实现ReentrantLock的使用，其...
读写锁ReadWriteLock
欢迎一起学习交流
04-19 2155
在jdk帮助文档中是这么说的：A ReadWriteLock维护一对关联的locks，一个用于只读操作，一个用于写操作。read lock可以由多个阅读器同时进行，只要没有作者 write lock 是独家的 意思就是读操作可以被多个线程同时读，写操作只能由一个线程去写 ReadWriteLock同Lock一样也是一个接口，提供了readLock和writeLock两种锁的操作机制，一个是只读的锁，一个是写锁。ReentranReadWriteLock是其...
ReadWriteLock读写锁（个人笔记）
学习笔记
07-20 191
对于读写锁，它的源码是这样的 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
ReadWriteLock读写锁的使用
HELLOW，文浩
07-15 204
说到Java并发编程，很多开发第一个想到同时也是经常常用的肯定是Synchronized，但是小编这里提出一个问题，Synchronized存在明显的一个性能问题就是读与读之间互斥，简言之就是，我们编程想要实现的最好效果是，可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写的效率，如何实现呢？ Java并发包中ReadWriteLock是一个接口，主要有两个方法，如下： public interface ReadWriteLock { /** * Returns th..
【Java并发】- ReentrantReadWriteLock，读写锁原理
LightOfMiracle的博客
06-13 2541
ReentrantReadWriteLock（读写锁）读写锁概述ReentrantReadWriteLock，读写锁或者重入读写锁，它维护了一个读锁和一个写锁，可以达到多个读线程可以共享的获取到锁，而此时写线程不能获取到锁，并且当写线程获取到锁时后续的读写都将被阻塞不能获取到锁。读写锁保证了写操作对后续的读操作的可见性。同时ReentrantReadWriteLock还支持重入，公平性选择以及锁的降
ReadWriteLock 是什么
siyuanwai的博客
08-16 272
首先明确一下，不是说ReentrantLock 不好，只是ReentrantLock 某些时候有局限。如果使用ReentrantLock，可能本身是为了防止线程A 在写数据、线程B 在读数据造成的数据不一致，但这样，如果线程C 在读数据、线程D 也在读数据，读数据是不会改变数据的，没有必要加锁，但是还是加锁了，降低了程序的性能。因为这个，才诞生了读写锁ReadWriteLock 。 ReadWriteLock 是一个读写锁接口， ReentrantReadWriteLock 是ReadWriteLock 接
Java并发编程：深入理解ReadWriteLock读写锁
文章提供了详细的解释和示例代码，帮助读者理解如何利用读写锁实现并发环境下的读写分离，以优化多线程对共享资源的访问效率。" 在Java并发编程中，ReadWriteLock接口位于java.util.concurrent.locks包下，它是Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值