摘要：二模式案例類數據類可以被多個線程同時訪問。共享資源參與者代表和所共享的資源對象，提供不改變內部狀態的操作，以及會改變內部狀態的操作。讀寫鎖參與者提供了對參與者進行操作和操作時需要的鎖定。

Read-Write Lock Pattern將讀取與寫入分開處理，在讀取數據之前必須獲取用來讀取的鎖定，而寫入的時候必須獲取用來寫入的鎖定。因為讀取時實例的狀態不會改變，所以多個線程可以同時讀取；但是，寫入會改變實例的狀態，所以當有一個線程寫入的時候，其它線程既不能讀取與不能寫入。

Data類：
數據類可以被多個線程同時訪問。

public class Data {
    private final char[] buffer;
    private final ReadWriteLock lock = new ReadWriteLock();
    public Data(int size) {
        this.buffer = new char[size];
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = "*";
        }
    }
    public char[] read() throws InterruptedException {
        lock.readLock();
        try {
            return doRead();
        } finally {
            lock.readUnlock();
        }
    }
    public void write(char c) throws InterruptedException {
        lock.writeLock();
        try {
            doWrite(c);
        } finally {
            lock.writeUnlock();
        }
    }
    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 doWrite(char c) {
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = c;
            slowly();
        }
    }
    private void slowly() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
        }
    }
}

WriterThread類：

public class WriterThread extends Thread {
    private static final Random random = new Random();
    private final Data data;
    private final String filler;
    private int index = 0;
    public WriterThread(Data data, String filler) {
        this.data = data;
        this.filler = filler;
    }
    public void run() {
        try {
            while (true) {
                char c = nextchar();
                data.write(c);
                Thread.sleep(random.nextInt(3000));
            }
        } catch (InterruptedException e) {
        }
    }
    private char nextchar() {
        char c = filler.charAt(index);
        index++;
        if (index >= filler.length()) {
            index = 0;
        }
        return c;
    }
}

ReaderThread類：

public class ReaderThread extends Thread {
    private final Data data;
    public ReaderThread(Data data) {
        this.data = data;
    }
    public void run() {
        try {
            while (true) {
                char[] readbuf = data.read();
                System.out.println(Thread.currentThread().getName() + " reads " + String.valueOf(readbuf));
            }
        } catch (InterruptedException e) {
        }
    }
}

ReadWriteLock類：
讀寫鎖需要防止以下兩類沖突：

“讀取”和“寫入”的沖突（read-write conflict）

“寫入”和“寫入”的沖突（write-write conflict）

注意：“讀取”和“讀取”之間不會沖突*

public final class ReadWriteLock {
    private int readingReaders = 0;        //正在讀取線程的數量 
    private int writingWriters = 0;     //正在寫入線程的數量
    public synchronized void readLock() throws InterruptedException {
        while (writingWriters > 0 ) {
            wait();
        }
        readingReaders++;                      
    }
    public synchronized void readUnlock() {
        readingReaders--;   
        notifyAll();
    }
    public synchronized void writeLock() throws InterruptedException {
        while (readingReaders > 0 || writingWriters > 0) {
            wait();
        }
        writingWriters++;                       
    }
    public synchronized void writeUnlock() {
        writingWriters--;     
        notifyAll();
    }
}

執行：

public class Main {
    public static void main(String[] args) {
        Data data = new Data(10);
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new WriterThread(data, "ABCDEFGHIJKLMNOPQRSTUVWXYZ").start();
        new WriterThread(data, "abcdefghijklmnopqrstuvwxyz").start();
    }
}

Read-Write Lock模式的角色如下：

Reader(讀取者)參與者

Reader參與者會對SharedResource進行讀。

Writer(寫入者)參與者

Writer參與者會對SharedResource進行寫。

SharedResource(共享資源)參與者

SharedResource代表Reader和Writer所共享的資源對象，SharedResource提供不改變內部狀態的read操作，以及會改變內部狀態的write操作。

ReadWriteLock(讀寫鎖)參與者

ReadWriteLock提供了對SharedResource參與者進行read操作和write操作時需要的鎖定。