今天讲另一个并发工具，叫读写锁。读写锁是一种分离锁，是锁应用中的一种优化手段。
考虑读多写少的情况，这时如果我们用synchronized或ReentrantLock直接修饰读/写方法未尝不可，如：

    public static class Rw {
        private int val;

        public synchronized int read() throws InterruptedException {
            Thread.sleep(1000);
            return val;
        }

        public synchronized void write(int value) throws InterruptedException {
            Thread.sleep(1000);
            this.val = value;
        }
    }

简单有效。
如果我们想做点优化的话（前面说了读的情况比较多），也许要用到读写锁ReadWriteLock了`。
先看代码：

    public static class Rw {
        private int val;

        public int read(Lock lock) throws InterruptedException {
            try {
                lock.lock();
                Thread.sleep(1000);
                return val;
            } finally {
                lock.unlock();
            }
        }

        public void write(Lock lock, int value) throws InterruptedException {
            try {
                lock.lock();
                Thread.sleep(1000);
                this.val = value;
            } finally {
                lock.unlock();
            }
        }
    }

调用：

    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        final Rw rw = new Rw();
        
        for (int i = 18; i < 20; i++) {
            new Thread(() -> {
                try {
                    rw.write(readWriteLock.writeLock(),1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        for (int i = 0; i < 18; i++) {
            new Thread(() -> {
                try {
                    int read = rw.read(readWriteLock.readLock());
                    System.out.println(read);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

ReentrantReadWriteLock是ReadWriteLock的常用子类。
代码逻辑比较简单，读的时候上读锁，写的时候上写锁。只有写的时候会阻塞等待，所以代码大概2秒钟执行结束。
这里面只需要注意一个问题：所有和写相关的都会阻塞，比如读-写同时进行，也会阻塞。