本文主要介绍ReadWriteLock，可重入读写锁的基本使用，该锁只能在单服务实例中使用，不适合分布式多服务实例集群。
A ReadWriteLock维护一对关联的locks，一个用于只读操作，一个用于写操作。read lock可以由多个阅读器同时进行，只要没有作者 write lock 是独家的。
基本意思可分为如下几种场景
- 写锁不存在、多次加读锁成功
- 写锁存在、加读锁失败、加写锁失败
- 读锁不存在、单次加写锁成功、多次加写锁只有第一个写锁能成功
- 读锁存在、加读锁成功、加写锁失败
基本方法介绍
创建读写锁
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
使用读锁readLock().lock()
如果该锁被写锁占有，则该方法会一直等待锁
ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); readWriteLock.readLock().lock();
使用读锁readLock().tryLock()；readLock().tryLock(6L, TimeUnit.SECONDS)
如果该锁被写锁占有，第一个方法如果获取不到锁则返回false，第二个方法会等待你设置的时间，在你设置的时间范围内未获取到锁则返回false
ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); readWriteLock.readLock().tryLock(); readWriteLock.readLock().tryLock(6L, TimeUnit.SECONDS);
使用写锁writeLock().lock()
如果该锁被写锁占有，则该方法会一直等待锁
ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); readWriteLock.writeLock().lock();
使用读锁writeLock().tryLock()；writeLock().tryLock(6L, TimeUnit.SECONDS)
如果该锁被写锁占有，第一个方法如果获取不到锁则返回false，第二个方法会等待你设置的时间，在你设置的时间范围内未获取到锁则返回false
ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); readWriteLock.writeLock().tryLock(); readWriteLock.writeLock().tryLock(6L, TimeUnit.SECONDS);
使用案例
创建LockManager
该实例的读方法用了等待6S
public class LockManager {
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void write(String message,Long sleep) {
try{
if(readWriteLock.writeLock().tryLock()){
try{
Thread.sleep(sleep);
System.out.println(Thread.currentThread().getName()+",写写写写写写写写写写，message="+message);
}catch (Exception ex){
System.out.println(Thread.currentThread().getName()+",写入异常"+ex);
}finally {
readWriteLock.writeLock().unlock();
}
}else{
System.out.println(Thread.currentThread().getName()+",获取写锁失败");
}
}catch (Exception ex){
ex.printStackTrace();
}
}
public void read(String message,Long sleep){
try{
if(readWriteLock.readLock().tryLock(6L, TimeUnit.SECONDS)){
try{
Thread.sleep(sleep);
System.out.println(Thread.currentThread().getName()+",读读读读读读读读读读，message="+message);
}catch (Exception ex){
System.out.println(Thread.currentThread().getName()+",读取异常"+ex);
}finally {
readWriteLock.readLock().unlock();
}
}else{
System.out.println(Thread.currentThread().getName()+",获取读锁失败");
}
}catch (Exception ex){
ex.printStackTrace();
}
}
}
测试无写锁，只有读锁
测试方法
第一个线程等待5S输出，第二个线程等待4S输出
@Test
public void testOnlyRead() throws Exception {
LockManager lockManager = new LockManager();
new Thread(()->lockManager.read("001",5000L)).start();
new Thread(()->lockManager.read("002",4000L)).start();
Thread.sleep(20000L);
}
输出结果
Thread-2,读读读读读读读读读读，message=002Thread-1,读读读读读读读读读读，message=001
测试无读锁，只有写锁
测试方法
第一个线程等待5S输出，第二个线程等待4S输出
@Test
public void testOnlyWrite() throws Exception {
LockManager lockManager = new LockManager();
new Thread(()->lockManager.write("001",5000L)).start();
new Thread(()->lockManager.write("002",4000L)).start();
Thread.sleep(20000L);
}
输出结果
Thread-2,获取写锁失败Thread-1,写写写写写写写写写写，message=001
测试先读锁，再写锁
测试方法
第一个线程等待5S输出，第二个线程等待4S输出
@Test
public void testReadWrite() throws Exception {
LockManager lockManager = new LockManager();
new Thread(()->lockManager.read("001",5000L)).start();
new Thread(()->lockManager.write("002",4000L)).start();
Thread.sleep(20000L);
}
输出结果
Thread-2,获取写锁失败Thread-1,读读读读读读读读读读，message=001
测试先写锁，再写锁
测试方法 （由于读锁获取等待了6S，所以可以执行成功）
第一个线程等待5S输出，第二个线程等待4S输出
@Test
public void testWriteRead() throws Exception {
LockManager lockManager = new LockManager();
new Thread(()->lockManager.write("001",5000L)).start();
new Thread(()->lockManager.read("002",4000L)).start();
Thread.sleep(20000L);
}
输出结果
Thread-1,写写写写写写写写写写，message=001Thread-2,读读读读读读读读读读，message=002
测试方法 （由于读锁获取等待了6S，所以读锁获取失败）
第一个线程等待7S输出，第二个线程等待4S输出
@Test
public void testWriteRead2() throws Exception {
LockManager lockManager = new LockManager();
new Thread(()->lockManager.write("001",7000L)).start();
new Thread(()->lockManager.read("002",4000L)).start();
Thread.sleep(20000L);
}
输出结果
Thread-2,获取读锁失败Thread-1,写写写写写写写写写写，message=001