public interface ReadWriteLock

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

public abstract interface ReadWriteLock
{
  public abstract Lock readLock();
  
  public abstract Lock writeLock();
}

访问约束

ReentrantReadWriteLock诞生于J·U·C。此后，国人一般称它为读写锁。人如其名，人如其名，她就是一个可重入锁，同时她还是一个读、写锁。
ReentrantReadWriteLock实现了ReadWriteLock和Serializable，同时ReadWriteLock跟Lock也没有继承关系。
ReentrantReadWriteLock跟ReentrantLock只有朋友关系，她们都是一个可重入锁。

eg:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest implements Runnable{
    private static ReentrantLock rl = new ReentrantLock();
    private static ReentrantReadWriteLock readwriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readwriteLock.readLock();
    private static Lock writeLock = readwriteLock.writeLock();
    
    public void handleRead(Lock lock) throws InterruptedException{
        try{
            lock.lock();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "   获得了读锁, 时间为" + 
                    System.currentTimeMillis());
        }finally{
            lock.unlock();
        }
    }
    
    public void handleWrite(Lock lock) throws InterruptedException{
        try{
            lock.lock();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "  获得了写锁, 时间为" + 
                    System.currentTimeMillis());
        }finally{
            lock.unlock();
        }
    }
    
    @Override
    public void run() {
        
        
    }
    
    public static void main(String[] args) {
        final ReadWriteLockTest rwlt = new ReadWriteLockTest();
        Runnable read = new Runnable(){
            public void run(){
                try {
                    rwlt.handleRead(readLock);
                    //rwlt.handleRead(rl);      //假如使用普通的重入锁，读写之间相互等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Runnable write = new Runnable(){
            public void run(){
                try{
                    rwlt.handleWrite(writeLock);
                    //rwlt.handleWrite(rl);     //假如使用普通的重入锁，读写之间相互等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread[] readThread = new Thread[10];
        for (int i = 0; i < 10; i++) {
            readThread[i] = new Thread(read);
            readThread[i].start();
        }
        Thread[] writeThread = new Thread[5];
        for (int i = 0; i < 5; i++) {
            writeThread[i] = new Thread(write);
            writeThread[i].start();
        }
    }

    
}

在JDK1.8之前，ReentrantReadWriteLock是ReadWriteLock的唯一实现，它由读、写锁组成，读是共享锁、写是独占锁，且读写互斥，它使用的依然是悲观的锁策略.如果有大量的读线程,他也有可能引起写线程的饥饿。JDK1.8，引进一种新的机制（StampedLock），StampedLock则提供了一种乐观的读策略,这种乐观策略的锁非常类似于无锁的操作,使得乐观锁完全不会阻塞写线程。