当线程 "读取" 实例状态时, 实例的状态不会发生改变, 当线程 "写入" 数据时, 实例的状态会发生改变, 在 Read-Write-Lock 模式中, 读取操作和写入操作是分开考虑的, 在执行读取操作之前, 线程必须获取用于读取的锁, 以防止其他线程写入, 而在执行写操作之前, 线程必须获取用于写入的锁
二. 示例程序| 类名 | 说明 |
| Main | 测试主程序 |
| ReadThread | 表示读取线程类 |
| WriteThread | 表示写入线程类 |
| Data | 可以被读写的类 |
| ReadWriteLock | 提供读写锁的类 |
Main 类会创建一个 Data 的实例, 然后创建对该 Data 实例读取操作的线程(ReadThread), 以及执行写入的线程(WriteThread), 并启动线程
public class Main {
public static void main(String[] args) {
Data data = new Data(10);
// 读线程
new ReadThread(data).start();
new ReadThread(data).start();
new ReadThread(data).start();
new ReadThread(data).start();
new ReadThread(data).start();
new ReadThread(data).start();
new ReadThread(data).start();
// 写线程
new WriteThread(data, "abcdefg").start();
new WriteThread(data, "ABCDEFG").start();
}
}
2.2 Data类
Data 类是可以执行读取和写入操作的类, buffer 字段是实际的读写对象的char类型数组, lock字段保存的是该模式的主角 ReadWriteLock 的实例, 构造函数会根据参数的传入长度来分配一个 char 数组, 并初始化 buffer 字段, read()方法用于执行读取操作, 实际的读取操作是通过 doRead()方法来执行, 而 doRead()方法 夹在 lock.readLock() 和 lock.readUnLock() 之间, lock.readLock() 表示获取用于读取的锁, lock.readUnLock() 表示释放用于读取的锁
public class Data {
private final char[] buffer;
private final ReadWriteLock lock = new ReadWriteLock();
public Data(int size) {
this.buffer = new char[size];
Arrays.fill(buffer, '*');
}
public char[] read() throws InterruptedException {
// 获取读锁
lock.readLock();
try {
return doRead();
} finally {
lock.readUnLock();
}
}
private char[] doRead() {
char[] newBuf = new char[buffer.length];
for (int i = 0; i < buffer.length; i++) {
newBuf[i] = buffer[i];
}
slowly();
return newBuf;
}
private void slowly() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
//
}
}
public void write(char c) throws InterruptedException {
// 获取写锁
lock.writeLock();
try {
doWrite(c);
} finally {
lock.writeUnLock();
}
}
private void doWrite(char c) {
for (int i = 0; i < buffer.length; i++) {
buffer[i] = c;
slowly();
}
}
}
2.3 WriteThraed类
WriteThread 类表示的是对 Data 实例执行写入操作的线程, 构造函数的参数 filler 是一个字符串, 程序会逐个取出里面的字符, 并 write 到 data 实例中, 每写入一次, 线程会随机 sleep 几秒
public class WriteThread extends Thread {
private static final Random r = new Random();
private final Data data;
private final String filler;
private int index = 0;
public WriteThread(Data data, String filler) {
this.data = data;
this.filler = filler;
}
@Override
public void run() {
try {
while (true) {
char c = newChar();
data.write(c);
Thread.sleep(r.nextInt(3000));
}
} catch (InterruptedException e) {
//
}
}
private char newChar() {
char c = filler.charAt(index);
index++;
if (index >= filler.length()) {
index = 0;
}
return c;
}
}
2.4 ReadThread类
ReadThread 表示的是执行读取线程的类, 该类会循环调用 data.read() 方法
public class ReadThread extends Thread {
private final Data data;
public ReadThread(Data data) {
this.data = data;
}
@Override
public void run() {
try {
while (true) {
char[] read = data.read();
System.out.println(Thread.currentThread().getName() + " reads " + String.valueOf(read));
Thread.sleep(3000);
}
} catch (InterruptedException e) {
//
}
}
}
2.6 ReadWriteLock类
该类提供了用于读取的锁和写入的锁, 为了确保安全性, 我们需要防止以下两种冲突 :
"读取" 和 "写入" 的冲突
"写入" 和 "写入" 的冲突
由于不存在 "读取" 和 "读取" 的冲突, 所以我们无需对其进行考虑
为了防止发生冲突, 获取用于读取的锁, 和用于写入的锁的条件, 一般存在一下四种情况 :
1. 当线程想要获取用于读取的锁时:
如果有线程正在执行写入, 则等待, 否则会引起 "读取" 和 "写入" 的冲突
如果有线程正在执行读取, 则无需等待, 因为不存在 "读取" 和 "读取" 的冲突
2. 当线程想要获取用于写入的锁时:
如果有线程正在执行写入, 则等待, 否则会引起 "写入" 和 "写入" 的冲突
如果有线程正在执行读取, 则等待, 否则会引起 "读取" 和 "写入" 的冲突
综上所述, 获取获取锁, 只会存在一种冲突, 但是获取写入所, 会存在两种冲突
package cn.demo05;
public class ReadWriteLock {
private int readingReaders = 0; // 实际正在读取中的线程格式
private int waitingWrites = 0; // 正在等待写入的线程个数
private int writingWrites = 0; // 实际正在写入的线程个数
private boolean preferWriter = true; // 若写入优化, 则为 true
public synchronized void readLock() throws InterruptedException {
// 读取时, 若存在正在写入的线程, 或 存在等待写入的线程, 则进入 wait
while (writingWrites > 0 || (preferWriter && waitingWrites > 0)) {
wait();
}
// 读线程++
readingReaders++;
}
public synchronized void readUnLock() {
readingReaders--;
preferWriter = true;
// 唤醒写线程
notifyAll();
}
public synchronized void writeLock() throws InterruptedException {
waitingWrites++;
try {
// 写入是, 若存在正在读取的线程, 或 实际正在写入的线程, 则进入 wait
while (readingReaders > 0 || writingWrites > 0) {
wait();
}
} finally {
waitingWrites--;
}
// 写线程++
writingWrites++;
}
public synchronized void writeUnLock() {
// 写线程--
writingWrites--;
preferWriter = false;
// 唤醒读线程, 或 其他写线程
notifyAll();
}
}
2.7 运行示例
如图所示, 该结果显示的是 ReadThraed 读取的内容, 当 WriteThread 线程写入时, 输出会暂停一下, 另外, 如果线程是不安全的, 那么打印的多个字符会交织在一起显示, (也就是说读取的时候, 有线程执行了写入)
Thread-2 reads aaaaaaaaaa Thread-4 reads aaaaaaaaaa Thread-3 reads aaaaaaaaaa Thread-5 reads aaaaaaaaaa Thread-1 reads aaaaaaaaaa Thread-0 reads aaaaaaaaaa Thread-1 reads AAAAAAAAAA Thread-4 reads AAAAAAAAAA Thread-3 reads AAAAAAAAAA Thread-0 reads AAAAAAAAAA Thread-2 reads AAAAAAAAAA三. Read-Write-Lock模式中的登场的角色 3.1 Reader(读者)
Reader 角色对 SharedResource 角色执行 read 操作, 在示例程序中, 由 ReadThread 类扮演
3.2 Writer(写者)Writer 角色对 SharedResource 角色执行 write 操作, 在示例程序中, 由 WriteThread 类扮演
3.3 SharedResource(共享资源)SharedResource 角色表示的是 Reader 和 Writer 共享的资源, SharedResource 角色提供不修改内部状态的操作 read() 方法和修改内部状态的操作 write() 方法, 在示例程序中, 有 Data 扮演
3.4 ReadWriteLock(读写锁)ReadWriteLock 角色提供了 SharedResource 实现 read() 方法和 write () 方法时所需要的锁, 也就是实现 read() 方法的 readLock 和 readUnLock, 和实现 write() 方法的 writeLock 和writeUnLock, 在示例程序中, 有 ReadWriteLock 类扮演该角色
3.5 模式类图四. 使用juc简化ReadWriteLock
只需要把自己设计的读写锁, 需改为juc包下的 ReentrantReadWriteLock 即可
package cn.demo05;
import java.util.Arrays;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Data {
private final char[] buffer;
// private final ReadWriteLock lock = new ReadWriteLock();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock readLock = lock.readLock();
private final Lock writeLock = lock.writeLock();
public Data(int size) {
this.buffer = new char[size];
Arrays.fill(buffer, '*');
}
public char[] read() throws InterruptedException {
// 获取读锁
// lock.readLock();
readLock.lock();
try {
return doRead();
} finally {
// lock.readUnLock();
readLock.unlock();
}
}
private char[] doRead() {
char[] newBuf = new char[buffer.length];
for (int i = 0; i < buffer.length; i++) {
newBuf[i] = buffer[i];
}
slowly();
return newBuf;
}
private void slowly() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
//
}
}
public void write(char c) throws InterruptedException {
// 获取写锁
// lock.writeLock();
writeLock.lock();
try {
doWrite(c);
} finally {
// lock.writeUnLock();
writeLock.unlock();
}
}
private void doWrite(char c) {
for (int i = 0; i < buffer.length; i++) {
buffer[i] = c;
slowly();
}
}
}



