Java基于ReadWriteLock实现锁的应用
所有ReadWriteLock实现都必须保证writeLock操作的内存同步效果也要保持与相关readLock的联系。也就是说，成功获取读锁的线程会看到写入锁之前版本所做的所有更新。
与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader线程），读-写锁利用了这一点。从理论上讲，与互斥锁相比，使用读-写锁所允许的并发性增强将带来更大的性能提高。在实践中，只有在多处理器上并且只在访问模式适用于共享数据时，才能完全实现并发性增强。
在writer释放写入锁时，reader和writer都处于等待状态，在这时要确定是授予读取锁还是授予写入锁。Writer优先比较普遍，因为预期写入所需的时间较短并且不那么频繁。Reader优先不太普遍，因为如果reader正如预期的那样频繁和持久，那么它将导致对于写入操作来说较长的时延。公平或者“按次序”实现也是有可能的。
在reader处于活动状态而writer处于等待状态时，确定是否向请求读取锁的reader授予读取锁。Reader优先会无限期地延迟writer，而writer优先会减少可能的并发。
我们创建信用卡类：
packagecom.entity;
publicclassBankCard{
privateStringcardid="XZ456789";
privateintbalance=10000;
publicStringgetCardid(){
returncardid;
}
publicvoidsetCardid(Stringcardid){
this.cardid=cardid;
}
publicintgetBalance(){
returnbalance;
}
publicvoidsetBalance(intbalance){
this.balance=balance;
}
}
里面有卡号和父母已经存的钱。
儿子花钱首先要获得写的锁把卡锁了，然后再花钱。之后放开这个锁。
packagecom.thread;
importjava.util.concurrent.locks.ReadWriteLock;
importcom.entity.BankCard;
/**
*@说明儿子类，只消费
*/
publicclassConsumerimplementsRunnable{
BankCardbc=null;
ReadWriteLocklock=null;
Consumer(BankCardbc,ReadWriteLocklock){
this.bc=bc;
this.lock=lock;
}
publicvoidrun(){
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(Exceptione){
e.printStackTrace();
}
}
}
父母类只监督这个卡的使用，获得的是读的锁。
packagecom.thread;
importjava.util.concurrent.locks.ReadWriteLock;
importcom.entity.BankCard;
/**
*@说明父母类，只监督
*/
publicclassConsumer2implementsRunnable{
BankCardbc=null;
inttype=0;
ReadWriteLocklock=null;
Consumer2(BankCardbc,ReadWriteLocklock,inttype){
this.bc=bc;
this.lock=lock;
this.type=type;
}
publicvoidrun(){
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(Exceptione){
e.printStackTrace();
}
}
}
运行程序，儿子开始花钱，父母两人一直在查看花钱情况。
packagecom.thread;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.locks.ReadWriteLock;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
importcom.entity.BankCard;
publicclassMainThread{
publicstaticvoidmain(String[]args){
BankCardbc=newBankCard();
ReadWriteLocklock=newReentrantReadWriteLock();
ExecutorServicepool=Executors.newCachedThreadPool();
Consumercm1=newConsumer(bc,lock);
Consumer2cm2=newConsumer2(bc,lock,1);
Consumer2cm3=newConsumer2(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
可以看到儿子花了一次钱后，父母把卡给锁了，儿子不能在花钱，但是父母两个人都可以一直查询卡的余额。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。