多线程系列之七：Read-Write Lock模式

一，Read-Write Lock模式

在Read-Write Lock模式中，读取操作和写入操作是分开考虑的。在执行读取操作之前，线程必须获取用于读取的锁。
在执行写入操作之前，线程必须获取用于写入的锁。所以：
当一个线程在读取时，其他线程可以读取，但是不可以写入。
当一个线程正在写入时，其他线程不可以读取或写入。
因为执行互斥处理会降低程序的性能，但是如果把写入的互斥处理和读取的互斥处理分开来考虑，就可以提高系统性能

二，示例程序

public final class ReadWriteLock {

    private int readingReaders = 0;//实际正在读取中的线程个数

    private int waitingWriters = 0;//正在等待写入的线程个数

    private int writingWriters = 0;//实际正在写入的线程个数

    private boolean preferWriter = true;//若写入优先，则为true

    public synchronized void readLock()throws InterruptedException{

        while (writingWriters > 0 || (preferWriter && waitingWriters > 0)){

            wait();

        }

        readingReaders++;//正在读取的线程个数加1

    }

    public synchronized void readUnlock(){

        readingReaders--;//正在读取的线程个数减1

        preferWriter = true;

        notifyAll();

    }

    public synchronized void writeLock()throws InterruptedException{

        waitingWriters++;//等待写入的线程加1

        try {

            while (readingReaders > 0 || writingWriters > 0){

                wait();

            }

        }finally {

            waitingWriters--;//等待写入的线程减1

        }

        writingWriters++;//正在写入的线程加1

    }

    public synchronized void writeUnlock(){

        writingWriters--;//正在写入的线程减1

        preferWriter = false;

        notifyAll();

    }

}

public class Data {

    private final char[] buffer;

    public 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();

        }

    }

    /**

     * 实际的读取操作，创建一个新的char数组newbuf,来复制buffer里的内容,并返回newbuf

     * @return

     */

    private char[] doRead(){

        char[] newbuf = new char[buffer.length];

        for (int i = 0; i < buffer.length; i++) {

            newbuf[i] = buffer[i];

        }

        slowly();

        return newbuf;

    }

    public void write(char c)throws InterruptedException{

        lock.writeLock();

        try {

            doWrite(c);

        }finally {

            lock.writeUnlock();

        }

    }

    /**

     * 实际的写入操作,每读取一个字符,就执行一次耗时操作。写入操作时间比读取操作时间长

     * @param c

     */

    public void doWrite(char c){

        for (int i = 0; i < buffer.length; i++) {

            buffer[i] = c;

            slowly();

        }

    }

    /**

     * 耗时操作,模拟处理业务逻辑

     */

    public void slowly(){

        try {

            Thread.sleep(50);

        }catch (InterruptedException e){

        }

    }

}

public class ReaderThread extends Thread {

    private final Data data;

    public ReaderThread(Data data){

        this.data = data;

    }

    @Override

    public void run() {

        try {

            while (true){

                char[] readbuf = data.read();

                System.out.println(Thread.currentThread().getName()+" reads "+

                        String.valueOf(readbuf));

            }

        }catch (InterruptedException e){

        }

    }

}

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;

    }

    @Override

    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;

    }

}

public class Test {

    public static void main(String[] args) {

        Data data = new Data(10);

        for (int i = 0; i < 6; i++) {

            new ReaderThread(data).start();

        }

        new WriterThread(data,"ABCDEFGHIJKLMNOPQRSTUVWXYZ").start();

        new WriterThread(data,"abcdefghijklmnopqrstuvwxyz").start();

    }

}

三，适用场景

1.读取操作频繁
2.读取频率比写入频率高

四，锁的含义

1.synchronized可以用于获取实例的锁，Java的每一个实例都持有一个锁，但同一个锁不能被两个以上的线程同时获取，
这种结构是Java编程规范规定的，java虚拟机也是这样实现的。这就是java提供的物理锁。
2.本章的用于读取的锁和用于写入的锁，是开发人员自己实现的一种结构。这种锁是逻辑锁，我们可以通过修改ReadWriteLock类来改变锁的运行
ReadWriteLock类提供了用于读取的锁和用于写入的锁的这两个逻辑锁。但是用于实现这两个逻辑锁的物理锁只有一个，就是ReadWriteLock实例持有的锁

五，java.util.concurrent.locks.ReadWriteLock

java并发包提供了读写锁。

public class Data {

    private final char[] buffer;

    private final ReadWriteLock lock = new ReentrantReadWriteLock(true);

    private final Lock readLock = lock.readLock();

    private final Lock writeLock = lock.writeLock();

    public Data(int size){

        this.buffer = new char[size];

        for (int i = 0; i < buffer.length; i++) {

            buffer[i] = '*';

        }

    }

    public char[] read()throws InterruptedException{

        readLock.lock();

        try {

            return doRead();

        }finally {

            readLock.unlock();

        }

    }

    /**

     * 实际的读取操作，创建一个新的char数组newbuf,来复制buffer里的内容,并返回newbuf

     * @return

     */

    private char[] doRead(){

        char[] newbuf = new char[buffer.length];

        for (int i = 0; i < buffer.length; i++) {

            newbuf[i] = buffer[i];

        }

        slowly();

        return newbuf;

    }

    public void write(char c)throws InterruptedException{

        writeLock.lock();

        try {

            doWrite(c);

        }finally {

            writeLock.unlock();

        }

    }

    /**

     * 实际的写入操作,每读取一个字符,就执行一次耗时操作。写入操作时间比读取操作时间长

     * @param c

     */

    public void doWrite(char c){

        for (int i = 0; i < buffer.length; i++) {

            buffer[i] = c;

            slowly();

        }

    }

    /**

     * 耗时操作,模拟处理业务逻辑

     */

    public void slowly(){

        try {

            Thread.sleep(50);

        }catch (InterruptedException e){

        }

    }

}

巴特西

多线程系列之七：Read-Write Lock模式

最新文章

热门文章