ReadWriteLock读写分离锁

public class ReadWriteLockDemo {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock writeLock = readWriteLock.writeLock();
    private int value;

    public Object handleRead(Lock lock) throws InterruptedException{
        try{
            lock.lock();
            Thread.sleep(1000);
            return value;
        }finally {
            lock.unlock();
        }
    }

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

    public static void main(String[] args) {
        final ReadWriteLockDemo demo = new ReadWriteLockDemo();
        Runnable readRunnale = new Runnable(){
            @Override
            public void run() {
                try{
                    demo.handleRead(readLock);
                    //demo.handleRead(lock);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        Runnable writeRunnale = new Runnable(){
            @Override
            public void run() {
                try{
                    demo.handleWrite(writeLock,new Random().nextInt());
                    //demo.handleWrite(lock,new Random().nextInt());
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        for(int i = 0;i <18; i++){
            new Thread(readRunnale).start();
        }
        for(int i =18;i<20;i++){
            new Thread(writeRunnale).start();
        }


    }

}

ReadWriteLock读写分离锁。
读写分离锁可以有效地帮助减少竞争。
读-读不互斥：读读之间不阻塞
读-写互斥：读阻塞写，写也会阻塞读。
写-写互斥：写写阻塞。
如果在系统中，读操作的次数远远大于写操作的次数，
则读写锁就可以发挥最大的功效，提升系统的性能。

Thread.sleep(1000);让线程耗时1秒，让他们分别对应读耗时和写耗时。
开启18个读线程，开启2个写线程。由于这里使用了读写分离。
因此，读线程完全并行，而写会堵塞读，因为，实际上这段代码运行大约2秒多就结束。
写线程之间实际是串行的。
而如果?
//demo.handleRead(lock);替代上一行。
//demo.handleWrite(lock,new Random().nextInt()); 替代上一行
即使用普通的重入锁代替读写锁，所有的读和写线程之间都必须相互等待。
因此整个程序的执行时间将长达20余秒。