Java基于ReadWriteLock实现锁的应用

 更新时间:2020年10月21日 10:14:02   作者:cuisuqiang  
这篇文章主要介绍了Java基于ReadWriteLock实现锁的应用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

所有 ReadWriteLock 实现都必须保证 writeLock 操作的内存同步效果也要保持与相关 readLock 的联系。也就是说,成功获取读锁的线程会看到写入锁之前版本所做的所有更新。

与互斥锁相比,读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(writer 线程)可以修改共享数据,但在许多情况下,任何数量的线程可以同时读取共享数据(reader 线程),读-写锁利用了这一点。从理论上讲,与互斥锁相比,使用读-写锁所允许的并发性增强将带来更大的性能提高。在实践中,只有在多处理器上并且只在访问模式适用于共享数据时,才能完全实现并发性增强。

在 writer 释放写入锁时,reader 和 writer 都处于等待状态,在这时要确定是授予读取锁还是授予写入锁。Writer 优先比较普遍,因为预期写入所需的时间较短并且不那么频繁。Reader 优先不太普遍,因为如果 reader 正如预期的那样频繁和持久,那么它将导致对于写入操作来说较长的时延。公平或者“按次序”实现也是有可能的。

在 reader 处于活动状态而 writer 处于等待状态时,确定是否向请求读取锁的 reader 授予读取锁。Reader 优先会无限期地延迟 writer,而 writer 优先会减少可能的并发。

我们创建信用卡类:

package com.entity; 
public class BankCard {  
  private String cardid = "XZ456789";  
  private int balance = 10000; 
  public String getCardid() { 
    return cardid; 
  } 
  public void setCardid(String cardid) { 
    this.cardid = cardid; 
  } 
  public int getBalance() { 
    return balance; 
  } 
  public void setBalance(int balance) { 
    this.balance = balance; 
  } 
} 

里面有卡号和父母已经存的钱。

儿子花钱首先要获得写的锁把卡锁了,然后再花钱。之后放开这个锁。

package com.thread; 
import java.util.concurrent.locks.ReadWriteLock; 
import com.entity.BankCard; 
/** 
 * @说明 儿子类,只消费 
 */ 
public class Consumer implements Runnable { 
  BankCard bc = null; 
  ReadWriteLock lock = null; 
  Consumer(BankCard bc, ReadWriteLock lock) { 
    this.bc = bc; 
    this.lock = lock; 
  } 
  public void run() { 
    try { 
      while(true){ 
        lock.writeLock().lock();  
        System.out.print("儿子要消费,现在余额:" + bc.getBalance() + "\t"); 
        bc.setBalance(bc.getBalance() - 2000); 
        System.out.println("儿子消费2000元,现在余额:" + bc.getBalance()); 
        lock.writeLock().unlock();  
        Thread.sleep(3 * 1000);  
      } 
    } catch (Exception e) { 
      e.printStackTrace(); 
    }     
  } 
} 

父母类只监督这个卡的使用,获得的是读的锁。

package com.thread;
import java.util.concurrent.locks.ReadWriteLock;
import com.entity.BankCard;
/**
 * @说明 父母类,只监督
 */
public class Consumer2 implements Runnable {
	BankCard bc = null;
	int type = 0;
	ReadWriteLock lock = null;
	Consumer2(BankCard bc, ReadWriteLock lock,int type) {
		this.bc = bc;
		this.lock = lock;
		this.type = type;
	}
	public void run() {
		try {
			while(true){
				lock.readLock().lock(); 
				if(type==2)
					System.out.println("父亲要查询,现在余额:" + bc.getBalance());
				else
					System.out.println("老妈要查询,现在余额:" + bc.getBalance());
				//lock.readLock().unlock();
				Thread.sleep(1 * 1000);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}		
	}
}

运行程序,儿子开始花钱,父母两人一直在查看花钱情况。

package com.thread; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.locks.ReadWriteLock; 
import java.util.concurrent.locks.ReentrantReadWriteLock; 
import com.entity.BankCard; 
public class MainThread { 
  public static void main(String[] args) { 
    BankCard bc = new BankCard(); 
    ReadWriteLock lock = new ReentrantReadWriteLock(); 
    ExecutorService pool = Executors.newCachedThreadPool(); 
    Consumer cm1 = new Consumer(bc, lock); 
    Consumer2 cm2 = new Consumer2(bc, lock , 1); 
    Consumer2 cm3 = new Consumer2(bc, lock , 2); 
    pool.execute(cm1); 
    pool.execute(cm2); 
    pool.execute(cm3); 
  } 
} 

我们来看一下运行结果:

儿子要消费,现在余额:10000 儿子消费2000元,现在余额:8000
老妈要查询,现在余额:8000
父亲要查询,现在余额:8000
父亲要查询,现在余额:8000
老妈要查询,现在余额:8000
老妈要查询,现在余额:8000
父亲要查询,现在余额:8000
儿子要消费,现在余额:8000 儿子消费2000元,现在余额:6000
父亲要查询,现在余额:6000
老妈要查询,现在余额:6000
老妈要查询,现在余额:6000
父亲要查询,现在余额:6000
父亲要查询,现在余额:6000
老妈要查询,现在余额:6000
老妈要查询,现在余额:6000
儿子要消费,现在余额:6000 儿子消费2000元,现在余额:4000
父亲要查询,现在余额:4000

读写锁是互斥的,但是对于读来说没有互斥性。

也就是说读和写必须分开,但是资源可以同时被几个线程访问。不管是读还是写没有释放锁,其他线程就一直等待锁的释放。

我们来注释父母监督时锁的释放:

lock.readLock().unlock();

儿子要消费,现在余额:10000 儿子消费2000元,现在余额:8000
父亲要查询,现在余额:8000
老妈要查询,现在余额:8000
老妈要查询,现在余额:8000
父亲要查询,现在余额:8000
老妈要查询,现在余额:8000
父亲要查询,现在余额:8000
老妈要查询,现在余额:8000
父亲要查询,现在余额:8000

可以看到儿子花了一次钱后,父母把卡给锁了,儿子不能在花钱,但是父母两个人都可以一直查询卡的余额。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

相关文章

  • 浅谈Java数组的一些使用方法及堆栈存储

    浅谈Java数组的一些使用方法及堆栈存储

    下面小编就为大家带来一篇浅谈Java数组的一些使用方法及堆栈存储。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2017-07-07
  • Java Web开发防止多用户重复登录的完美解决方案

    Java Web开发防止多用户重复登录的完美解决方案

    在web项目开发中,很多情况下都可以让同一个账号信息在不同的登录入口登录很多次,这样子做的不是很完善。一般解决这种情况有两种解决方案,小编呢主要以第二种方式给大家介绍具体的实现方法,对java web 防止多用户重复登录的解决方案感兴趣的朋友一起看看吧
    2016-11-11
  • Mybatis自动创建表和更新表结构

    Mybatis自动创建表和更新表结构

    这篇文章主要介绍了Mybatis自动创建表和更新表结构的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下
    2016-06-06
  • Spring Bean生命周期之Bean元信息的配置与解析阶段详解

    Spring Bean生命周期之Bean元信息的配置与解析阶段详解

    这篇文章主要为大家详细介绍了Spring Bean生命周期之Bean元信息的配置与解析阶段,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2022-03-03
  • java环境变量为什么要配置path和classpath详细解答

    java环境变量为什么要配置path和classpath详细解答

    为何配置path?为何配置classpath?当时初学java时只是关心如何做而不去关心这些问题,接下来介绍一下,感兴趣的朋友可以参考下哦
    2013-01-01
  • 基于Java Tomcat和激活MyEclips的深入理解

    基于Java Tomcat和激活MyEclips的深入理解

    本篇文章是对Java中的Tomcat和激活MyEclips进行了详细的分析介绍,需要的朋友参考下
    2013-05-05
  • 浅析spring定时器的使用

    浅析spring定时器的使用

    这篇文章主要介绍了浅析spring定时器的使用,帮助大家更好的理解和学习spring框架,感兴趣的朋友可以了解下
    2020-10-10
  • Springboot+MybatisPlus+Oracle实现主键自增的示例代码

    Springboot+MybatisPlus+Oracle实现主键自增的示例代码

    这篇文章主要介绍了Springboot+MybatisPlus+Oracle实现主键自增的示例代码,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-11-11
  • Java实现的双向匹配分词算法示例

    Java实现的双向匹配分词算法示例

    这篇文章主要介绍了Java实现的双向匹配分词算法,结合完整实例形式详细分析了双向匹配分词算法的原理与java实现技巧,需要的朋友可以参考下
    2017-12-12
  • Java连接mysql数据库的详细教程(推荐)

    Java连接mysql数据库的详细教程(推荐)

    这篇文章主要介绍了Java连接mysql数据库的详细教程,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-08-08

最新评论