读写锁设计模式

---

前言

承接上一节讲单线程执行设计模式中例子的问题：读和写用的是同一个锁。当多个线程同时需要进行读操作的时候，只有一个线程能够读，其它线程被阻塞。导致读操作的串行化，这会使得程序的执行效率降低。为了解决这个问题，我们要将读操作并行化。于是就有了ReadWriteLock Design Pattern（读写锁设计模式）。

一、什么是读写锁设计模式

读写锁设计模式就是将读锁和写操作分离开来，主要是为了使得读操作并行化，多个线程可以同时进行读操作，以提高代码的执行效率。

二、问题考虑

在正式讲读写锁设计模式之前，我们先来考虑一个问题：读操作什么时候都进行吗？
答案是否定的，当有别的线程在进行写操作，这时我们不能进行读操作。只有当前没有任何线程在进行写操作的时候我们才能进行读操作。其它情况需要按照如下图去严格执行。不然写出的程序就不是线程安全的，这时候，程序执行效率再高都没有意义了。

三、读写锁设计

上图Y/N带表的是：是否不允许。可以这样理解，当有线程在读的时候，别的线程是可以进行读操作，但是别的线程不能进行写操作。当有线程在写的时候，别的线程既不能进行读操作也不能进行写操作。
首先我们要定义以下几个变量。
waitingReaders：正在等待读的线程的数量
readingReaders：正在进行读操作的线程的数量
waitingWriters：正在等待写的线程的数量
writingWriters：正在写的线程的数量

当有线程需要进行读操作的时候，这时就要拿到读锁。因为可能还没有获取到读锁，所以waitingReaders++，如果这时有别的线程在进行写操作，当前线程就不能进行读操作，要不断调用wait()方法进入阻塞状态，直到当前进行读操作的线程数writingWriters为0为止。最终线程能进行读操作，waitingReaders–

当有线程要进行写操作的时候，这时要去抢写锁，同样因为可能还没有获取到写锁，所以waitingWriters++，如果这时有别的线程在进行读操作或者有别的线程在进行写操作，当前线程就不能进行写操作，要不断调用wait()方法进入阻塞状态，直到当前的readingReaders和writingWriters都为0为止。最终现场能够进行写操作，所以waitingWriters–

当有线程要释放读锁的时候，readingReaders–，然后要调用notifyAll()方法。
当有线程要释放写锁的时候，writingWriters–，然后要调用notifyAll()方法。

代码如下：

package readwritelock;

public class ReadWriteLock {
    private int waitingReaders = 0;
    private int readingReaders = 0;
    private int waitingWriters = 0;
    private int writingWriters = 0;
    private boolean preferWriter = true;

    public ReadWriteLock () {
        this(true);
    }

    public ReadWriteLock (boolean preferWriter) {
        this.preferWriter = preferWriter;
    }

    public synchronized void readLock() {
        waitingReaders++;
        try {
            while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
                this.wait();
            }
            readingReaders++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            waitingReaders--;
        }
    }

    public synchronized void writeLock() {
        waitingWriters++;
        try {
            while (readingReaders > 0 || writingWriters > 0) {
                this.wait();
            }
            writingWriters++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            waitingWriters--;
        }
    }

    public synchronized void readUnLock() {
        readingReaders--;
        this.notifyAll();
    }

    public synchronized void writeUnLock() {
        waitingWriters--;
        this.notifyAll();
    }
}

四、需求分析

我们需求是多个线程同时对buffer缓冲进行读和写操作，应用读写锁设计模式。提高读效率，保证线程安全。

1、共享资源

这里要定义一个资源共享类，共享资源就是buffer缓冲区，这里使用一个char[]，共享资源要提供读和写的方法供线程调用。重要的点就是怎么读和怎么写了：先拿到读锁或者写锁，然后进行读或者写操作，最后释放锁

代码如下：

package readwritelock;

public class SharedData {
    private final char[] buffer;
    private static final ReadWriteLock LOCK = new ReadWriteLock();
    public SharedData(int size) {
        this.buffer = new char[size];
        for (int i = 0; i < size; i++) {
            this.buffer[i] = '*';
        }
    }

    public char[] read() {
        LOCK.readLock();
        char[] newBuffer = doRead();
        LOCK.readUnLock();
        return newBuffer;
    }

    private char[] doRead() {
        char[] newBuffer = new char[buffer.length];
        for (int i = 0; i < buffer.length ; i++)
            newBuffer[i] = buffer[i];
        slowly(50);
        return newBuffer;
    }

    public void writer(char c) {
        LOCK.writeLock();
        doWrite(c);
        LOCK.writeUnLock();
    }

    private void doWrite(char c) {
        for (int i = 0; i <buffer.length ; i++)
            buffer[i] = c;
        slowly(10);
    }

    private void slowly(int ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
        }
    }
}

2、写工作线程

写工作线程，首先要对共享资源进行操作，那么就需要有共享资源的属性，线程启动，就对buffer进行写。

package readwritelock;

import java.util.Random;

public class WriterWorker extends Thread {
    private final SharedData data;
    private final String filler;
    private final Random random = new Random(System.currentTimeMillis());
    private int index = 0;

    public WriterWorker(SharedData data, String filler) {
        this.data = data;
        this.filler = filler;
    }

    @Override
    public void run() {
        try {
            while (true) {
                char c = nextChar();
                data.writer(c);
                Thread.sleep(random.nextInt(1000));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private char nextChar() {
        char c = filler.charAt(index);
        index++;
        if (index > filler.length()) {
            index = 0;
        }
        return c;
    }
}

3、读工作线程

与写线程一样，需要有共享资源属性

package readwritelock;
public class ReaderWorker extends Thread {

    private final SharedData data;

    public ReaderWorker(SharedData 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) {
            e.printStackTrace();
        }
    }
}

4、客户端

package readwritelock;

/**
 * ReadWriteLock design pattern
 * Reader-Writer design pattern
 */
public class ReadWritLockClient {
    public static void main(String[] args) {
        final SharedData sharedData = new SharedData(10);
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new WriterWorker(sharedData, "qwertyuiopasdfg").start();
        new WriterWorker(sharedData, "QWERTYUIOPASDFG").start();
    }
}