读写锁，我们在多线程中，也是经常遇到。

    可以一起读，不可以一起写。也就是可以共患难，不可以共富贵。

    怎么才可以做到可以共患难，不可以共富贵呢？其实也不难。四标志位就可以打造最简单的读写锁。

    readingReader = 0 正在读的线程数
    writingWriter = 0 正在写的线程数
    waitingwriter = 0 正在等待写的线程数

    preferWriter = true 写入优先

    对于读，多少线程都是可以的，
    对于写，只允许一个线程
    对于其他要写的线程，那就进入等待写队列

    有几个冲突是我们需要处理的，那就是 读和写，写和写，写读。

    读写：当读的时候获取 读锁，当要获取写多的时候，我们要看读锁是否释放了，或者是否读完毕了。当没有读的线程的时候，就获取了写锁。

    写写：当写的时候获取 写锁，当另一个线程也要写的，等待写的数量加一，如果没有写的线程，就轮到他了，如果有那就等待。如果有多个写等待，最后是谁获得这个写锁，就看运气了，这就是非公平锁。

    写读：当写的时候获取 写锁，当另一个线程要读的，需要看看是否还有写的线程，如果没有就轮到读锁了。

    至于 preferWriter 这个flag 我们来想这么一个情况啊，如果写锁，等待写的线程还有两个，但是某些原因你把写锁解了。接着你要读锁，如果没有这个 preferWriter ，那么明显有等待写的线程，需要等待才好，这样明显不太符合我们的本意，所以就有了这个 preferWriter 当写锁 解开的时候 赋值为false。那么就是读锁优先。

    1. public class ReadWriteLock {
    3.     private int readingReader = 0;//正在读的线程数
    4.     private int writingWriter = 0;//正在写的线程数
    5.     private int waitingWriter = 0;//正在等待写的线程数
    7.     private boolean preferWriter = true;//如果写入优先 那么就是true
    10.     public synchronized void readLock() throws InterruptedException {
    11.         while (writingWriter > 0 || (preferWriter && waitingWriter > 0)) {
    12.             wait();
    13.         }
    14.         readingReader++;
    15.     }
    17.     public synchronized void readUnlock() {
    18.         readingReader--;
    19.         preferWriter = true;
    20.         notifyAll();
    21.     }
    23.     public synchronized void writeLock() throws InterruptedException {
    24.         waitingWriter++;
    26.         try {
    28.             while (readingReader > 0 || writingWriter > 0) {
    29.                 wait();
    30.             }
    31.         } finally {
    32.             waitingWriter--;
    33.         }
    34.         writingWriter++;
    35.     }
    37.     public synchronized void writeUnlock() {
    38.         writingWriter--;
    39.         preferWriter = false;
    40.         notifyAll();
    41.     }
    43. }
    1. public class ReadThread extends Thread {
    3.     private final Data data;
    5.     public ReadThread(Data data) {
    6.         this.data = data;
    7.     }
    9.     @Override
    10.     public void run() {
    11.         super.run();
    12.         try {
    13.             while (true) {
    14.                 char[] readBuf = data.read();
    15.                 System.out.println(Thread.currentThread().getName() + "-reads-" + String.valueOf(readBuf));
    16.             }
    17.         } catch (InterruptedException e) {
    18.             e.printStackTrace();
    19.         }
    20.     }
    21. }
    1. public class WriteThread  extends Thread{
    2.     private final  Data data;
    3.     private Random random = new Random();
    4.     private String filter;
    5.     private int index = 0;
    7.     public WriteThread(Data data,String filter) {
    8.         this.data = data;
    9.         this.filter = filter;
    10.     }
    12.     @Override
    13.     public void run() {
    14.         super.run();
    15.         try {
    16.             while (true){
    17.                 char c = nextChar();
    18.                 data.writee(c);
    19.                 Thread.sleep(random.nextInt(1000));
    20.             }
    21.         }catch (InterruptedException e){
    23.         }
    24.     }
    26.     private char nextChar() {
    27.         char c = filter.charAt(index);
    28.         index++;
    29.         if(index>=filter.length()){
    30.             index = 0;
    31.         }
    32.         return c;
    33.     }
    34. }
    1. public class Data {
    3.     private final ReadWriteLock lock = new ReadWriteLock();
    4.     private final char[] buffer;
    6.     public Data(int size) {
    7.         buffer = new char[size];
    8.         for (int i = 0; i < buffer.length; i++) {
    9.             buffer[i] = '*';
    10.         }
    11.     }
    13.     public char[] read() throws InterruptedException {
    14.         lock.readLock();
    15.         try {
    16.             return doRead();
    17.         } finally {
    18.             lock.readUnlock();
    19.         }
    20.     }
    22.     public void writee(char c) throws InterruptedException {
    23.         lock.writeLock();
    24.         try {
    25.             doWrite(c);
    26.         }finally {
    27.             lock.writeUnlock();
    28.         }
    32.     }
    34.     private void doWrite(char c) {
    35.         for (int i = 0; i < buffer.length; i++) {
    36.             buffer[i] = c;
    37.             slowly();
    38.         }
    39.     }
    41.     private char[] doRead() {
    42.         char[] newbuf = new char[buffer.length];
    43.         for (int i = 0; i < buffer.length; i++) {
    44.             newbuf[i] = buffer[i];
    45.         }
    46.         slowly();
    47.         return newbuf;
    48.     }
    50.     private void slowly() {
    51.         try {
    52.             Thread.sleep(50);
    53.         } catch (InterruptedException e) {
    54.             e.printStackTrace();
    55.         }
    56.     }
    57. }
    1. public class Main {
    4.     public static void main(String[] args) {
    5.         Data data = new Data(10);
    6.         new ReadThread(data).start();
    7.         new ReadThread(data).start();
    8.         new ReadThread(data).start();
    9.         new ReadThread(data).start();
    10.         new ReadThread(data).start();
    11.         new ReadThread(data).start();
    12.         new WriteThread(data,"ABCDEF").start();
    13.         new WriteThread(data,"abcdef").start();
    14.     }
    15. }