读写锁简介
所谓的读写锁值得是两把锁,在进行数据写入的时候有一个把“写锁”,而在进行数据读取的时候有一把“读锁”。
写锁会实现线程安全同步处理操作,而读锁可以被多个对象读取获取。
读写锁:ReadWriteLock
读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,这是由JVM自己控制的。
ReentrantReadWriteLock会使用两把锁来解决问题,一个读锁(多个线程可以同时读),一个是写锁(单个线程写)。
ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock,而WriteLock则是完全的互斥。这一特性最为重要,因为对于高读取频率而相对较低写入的数据结构,使用此类锁同步机制则可以提高并发量。
ReadWriteLock接口定义
packagejava.util.concurrent.locks;public interfaceReadWriteLock {
Lock readLock();//读锁
Lock writeLock(); //写锁
}
ReentrantReadWriteLock类定义
packagejava.util.concurrent.locks;public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable
ReentrantReadWriteLock类结构
小例子:银行存款简单实现
编写一个银行存款的程序,现在有10个人向银行账户存款,存放的一定要采用独占锁(写锁),而在读取的时候所有的线程都可以读取,应该使用共享锁也就是写锁。
在ReadWriteLock接口里面可以发现有两个方法可以获得锁:
获得写锁:public Lock writeLock();
获得读锁:public Lock readLock();
范例:利用读写锁操作实现存款与查看
packageso.strong.mall.concurrent;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.locks.ReadWriteLock;importjava.util.concurrent.locks.ReentrantReadWriteLock;public classBankDemo {public static voidmain(String[] args) {final Account account = new Account("iTermis", 15.0);final double[] money = new double[]{5.0, 300.0, 5000.0, 50000.0, 1000.0}; //准备要存入的金额
final int len =money.length;for (int i = 0; i < 2; i++) { //设置两个写线程
new Thread(newRunnable() {
@Overridepublic voidrun() {for (int j = 0; j < len; j++) {
account.saveMoney(money[j]);
}
}
},"存款用户-" +i).start();
}for (int i = 0; i < 10; i++) { //设置10个读线程
new Thread(newRunnable() {
@Overridepublic voidrun() {
System.out.println(Thread.currentThread().getName()+ "查账,账户名: " + account.getName() + ",资产总额: " +account.loadMoney());
}
},"收款人iTermis-" +i).start();
}
}
}classAccount {private String name; //开户名
private double asset = 10.0; //银行资产
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); //读写分离
public Account(String name, doubleasset) {this.name =name;this.asset =asset;
}//存款处理
public boolean saveMoney(doublemoney) {this.readWriteLock.writeLock().lock(); //对写入数据进行锁定处理
try{
System.out.println("【(" + Thread.currentThread().getName() + ")存款-BEFORE】存款金额:" +money);
TimeUnit.SECONDS.sleep(1);if (money > 0.0) {this.asset +=money;return true; //存款成功
}
}catch(Exception e) {
e.printStackTrace();
}finally{
System.out.println("【(" + Thread.currentThread().getName() + ")存款-AFTER】存款金额:" +getAsset());this.readWriteLock.writeLock().unlock(); //进行解锁处理
}return false;
}//返回当前的资金
public doubleloadMoney() {this.readWriteLock.readLock().lock();try{return this.getAsset();
}finally{this.readWriteLock.readLock().unlock();
}
}publicString getName() {returnname;
}
privatedoublegetAsset() {returnasset;
}
}
【(存款用户-0)存款-BEFORE】存款金额:5.0
【(存款用户-0)存款-AFTER】存款金额:20.0
【(存款用户-0)存款-BEFORE】存款金额:300.0
【(存款用户-0)存款-AFTER】存款金额:320.0
【(存款用户-0)存款-BEFORE】存款金额:5000.0
【(存款用户-0)存款-AFTER】存款金额:5320.0
【(存款用户-0)存款-BEFORE】存款金额:50000.0
【(存款用户-0)存款-AFTER】存款金额:55320.0
【(存款用户-0)存款-BEFORE】存款金额:1000.0
【(存款用户-0)存款-AFTER】存款金额:56320.0
【(存款用户-1)存款-BEFORE】存款金额:5.0
【(存款用户-1)存款-AFTER】存款金额:56325.0
【(存款用户-1)存款-BEFORE】存款金额:300.0
【(存款用户-1)存款-AFTER】存款金额:56625.0
【(存款用户-1)存款-BEFORE】存款金额:5000.0
【(存款用户-1)存款-AFTER】存款金额:61625.0
【(存款用户-1)存款-BEFORE】存款金额:50000.0
【(存款用户-1)存款-AFTER】存款金额:111625.0
【(存款用户-1)存款-BEFORE】存款金额:1000.0
【(存款用户-1)存款-AFTER】存款金额:112625.0
收款人iTermis-0查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-3查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-6查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-1查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-9查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-2查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-8查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-7查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-5查账,账户名: iTermis,资产总额: 112625.0
收款人iTermis-4查账,账户名: iTermis,资产总额: 112625.0
独占锁处理的速度很慢,但是可以保证线程数据的安全性,而共享锁处理速度快,是对多个线程进行的锁处理机制。
ps:这个读写的处理关系是重要类集ConcurrentHashMap的核心实现思想,当然这是后话。