本文作者：王一飞，叩丁狼高级讲师。原创文章，转载请注明出处。
接上篇,本篇讲解线程另外一个设计模式:Read-Write Lock Pattern.
概念
Read是读, 指获取/查询数据的线程, Write是写，指操作(增删改)数据的线程.
Read-Write Lock 模式要求：
1>在读模式时，多个线程可以同时执行读操作，但不允许写操作
2>在写模式时，只允许一个线程执行写操作，不允许其他线程进行读写
简单讲就是常说的：读写互斥
参与角色
Reader
读线程，拥有对共享资源读操作权限
Writer
写线程，拥有对共享资源写操作权限
Resource
共享资源， Reader/writer角色共享的资源， 一般具有2个方法，一个不改变资源状态的读操作， 一个可改变资源状态的写操作。
读写锁
锁对象，提供读锁， 写锁，在reader/writer角色读写时，加锁实现读写互斥
演示案例
需求：5个线程读，5个线程写实现读写互斥
Read-Write Lock Pattern难点在于怎么控制读写互斥，而读写互斥可以拆分为：
1>读取与写入的冲突
2>写入与写入的冲突
3>写入与读取的冲突
思考：读写怎么互斥法
1:读模式时(线程尝试读操作)
a>如果此时已经有线程在读，允许读
b>如果此时已经有线程在写，暂停当前线程
2:写模式时(线程尝试写操作)
a>如果此时已经有线程在读，暂定当前线程
b>如果此时已经有线程在写，暂停当前线程
根据上面分析，很容易可以找到需求突破口
1>线程满足某个条件需要暂停等待----线程wait/notifyall操作
2>这里某个条件是当前在读/在写的线程数量-----线程计数
3>使用同一锁对象对多线程的读写互斥控制
结论：
设计：ReadWriteLock 读写锁控制类
readCount : 当前读线程数量
writeCount: 当前写线程数量
readLock()： 获取读锁，成功执行，不成功等待
unReadLock(): 操作结束后释放读锁
writeLock: 获取写锁，成功执行，不成功等待
unWriteLock: 操作结束后释放写锁
//互斥锁控制类
public class ReadWriteLock {
//读线程个数
private int readCount;
//写线程个数
private int writeCount;
public synchronized String info(){
return "读线程：" + readCount + ", 写线程：" + writeCount;
}
//获取读锁
public synchronized void readLock() throws InterruptedException {
//此时有写线程操作，暂停
while(writeCount > 0 ){
wait();
}
//没有读写线程+1
readCount++;
System.out.println("读模式：" +info());
}
//释放读锁
public synchronized void unReadLock(){
readCount--; //读线程减少
notifyAll(); //唤醒等待线程:读或者写
}
//获取写锁
public synchronized void writeLock() throws InterruptedException {
//此时有读线程操作，暂停
//此时有写线程操作，暂停
while(readCount > 0 || writeCount > 0){
wait();
}
//没有读写线程+1
writeCount++;
System.out.println("写模式：" +info());
}
//释放写锁
public synchronized void unWriteLock(){
writeCount--; //读线程减少
notifyAll(); //唤醒等待线程:读或者写
}
}
操作的资源
//共享资源
//共享资源
public class Resource {
//读与写数据
private String data = "init";
//控制data数据的读写互斥
private ReadWriteLock lock = new ReadWriteLock();
//对data数据的读操作
public void read() throws InterruptedException {
lock.readLock();
try {
System.out.println(Thread.currentThread().getName()+"--read--：" + data);
}finally {
lock.unReadLock();
}
}
//对data数据的写操作
public void write(String d) throws InterruptedException {
lock.writeLock();
try {
data = d;
System.out.println(Thread.currentThread().getName()+" -write-：" + data);
}finally {
lock.unWriteLock();
}
}
}
测试类
public class App {
public static void main(String[] args) {
final Resource data = new Resource();
//5个读
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
public void run() {
while (true){
try {
data.read();
Thread.sleep(new Random().nextInt(200));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"read_" + i).start();
}
//5个写
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
public void run() {
while (true){
try {
data.write(Thread.currentThread().getName());
Thread.sleep(new Random().nextInt(200));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"write_" + i).start();
}
}
}
执行效果：
读模式：读线程：1, 写线程：0
read_0--read--：init
读模式：读线程：2, 写线程：0
read_3--read--：init
读模式：读线程：3, 写线程：0
read_2--read--：init
读模式：读线程：4, 写线程：0
read_1--read--：init
读模式：读线程：1, 写线程：0
read_4--read--：init
写模式：读线程：0, 写线程：1
write_0 -write-：write_0
写模式：读线程：0, 写线程：1
write_1 -write-：write_1
写模式：读线程：0, 写线程：1
write_2 -write-：write_2
写模式：读线程：0, 写线程：1
write_3 -write-：write_3
写模式：读线程：0, 写线程：1
write_4 -write-：write_4
写模式：读线程：0, 写线程：1
write_0 -write-：write_0
读模式：读线程：1, 写线程：0
read_3--read--：write_0
写模式：读线程：0, 写线程：1
write_4 -write-：write_4
读模式：读线程：1, 写线程：0
read_1--read--：write_4
读模式：读线程：1, 写线程：0
read_4--read--：write_4
读模式：读线程：1, 写线程：0
read_2--read--：write_4
写模式：读线程：0, 写线程：1
write_0 -write-：write_0
写模式：读线程：0, 写线程：1
write_1 -write-：write_1
读模式：读线程：1, 写线程：0
从输出效果看， 当读线程有值时，不会进行写操作， 但读操作可以同时进行,比如：读模式时，读线程：4，写线程为：0。 反之，当写线程出现1时，写线程全部为0， 另外写线程个数不会超过1
使用场景
Read-Write Lock Pattern讲究是读写互斥，读不进行安全控制， 写时需要控制。相对读写都进行安全控制的模式来说，性能上还是有一定提升， 但不绝对。Read-Write Lock Pattern更使用与读频率远高与写频率的安全操作。
jdk中其实也有读写锁操作
//共享资源
public class Resource {
//读与写数据
private String data = "init";
//控制data数据的读写互斥
// private ReadWriteLock lock = new ReadWriteLock();
//jdk
private final ReadWriteLock lock = new ReentrantReadWriteLock(true);
private final Lock readLock = lock.readLock();
private final Lock writeLock = lock.writeLock();
//对data数据的读操作
public void read() throws InterruptedException {
//lock.readLock();
readLock.lock();
try {
System.out.println(Thread.currentThread().getName()+"--read--：" + data);
}finally {
//lock.unReadLock();
readLock.unlock();
}
}
//对data数据的写操作
public void write(String d) throws InterruptedException {
//lock.writeLock();
writeLock.lock();
try {
data = d;
System.out.println(Thread.currentThread().getName()+" -write-：" + data);
}finally {
// lock.unWriteLock();
writeLock.unlock();
}
}
}