ReentrantReadWriteLock类，该类实现了锁的读写分离

里面有两个内部类WriteLock、ReadLock

我们都知道在并发编程过程中，只有加锁才能保证代码的有条不紊的进行，但不是每段代码都要进行加锁操作，比如在读取数据操作的一类代码中就不要加锁，从而提升程序的性能

而该ReentrantReadWriteLock类中就实现了锁的读写分离

该类的特点是

1、对数据的读取的时候，拿到readLock进行操作，如果要对数据进行修改时，拿到相应的WriteLock锁，才能对其修改，如果有其它线程拿到readLock锁正在进行读取操作的时候，这时再去获取WriteLock锁时，程序会一直阻塞下去，直到其它线程全部释放readLock锁

2、readLock锁可以被多个线程同时占用，因此readLock锁是共享锁

3、writeLock锁，只能同时被一个线程占用，其它线程要再去获取writeLock锁时，只能等待该线程释放writeLock锁

注意：在操作的过程中，记得释放

    private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(true);
    private static final ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock()
    private static final ReadLockTest test = new ReadLockTest();
    private static volatile int num = 0;
public void writePlus() throws InterruptedException {
        System.out.println(Thread.currentThread().getName()+"开始加一");
        System.out.println("上次的值是 "+num+" 加完之后 "+ ++num);
        System.out.println(Thread.currentThread().getName()+"加一结束，开始睡2秒");
        Thread.sleep(2000);
    }
    public static void write() {
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                writeLock.lock();
                try {
                    test.writePlus();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("---------------------------");
                writeLock.unlock();
            }).start();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) throws InterruptedException {
        write()
        System.out.println("main"+"线程结束");
    }

程序执行结果：

Thread-1开始加一
main执行结束
main线程结束
上次的值是 0 加完之后 1
Thread-1加一结束，开始睡2秒
---------------------------
Thread-0开始加一
上次的值是 1 加完之后 2
Thread-0加一结束，开始睡2秒
---------------------------

由输出的结果可知

writeLock锁和一般的加synchronized代码段几乎没有差别

    private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(true);
    private static final ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock()
    private static final ReadLockTest test = new ReadLockTest();
    private static volatile int num = 0;
    public void readLockPlus() throws InterruptedException {
        System.out.println("读取到的num "+0+" 线程sleep 2秒");
        Thread.sleep(2000);
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }

    public static void read() {
        for (int i = 0; i < 2; i++) {

            new Thread(() -> {
                readLock.lock();
                try {
                    test.readLockPlus();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) throws InterruptedException {
        write()
        System.out.println("main"+"线程结束");
    }

结果输出：
读取到的num 0 线程sleep 2秒
读取到的num 0 线程sleep 2秒
main执行结束
main线程结束
Thread-1线程结束
Thread-0线程结束

由输出可知

对该线程加readLock锁后，其结果和没有加的一样，哪加了有什么意义？

其实我们在加了readLock锁后，是保证代码在对num进行读取的时候，防止其它线程拿到writeLock锁对num的值进行修改

在上述的代码中，read()方法里面只有获取锁的这一操作，而没有释放锁的操作，说明readLock锁是一个共享锁

    private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(true);
    private static final ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock()
    private static final ReadLockTest test = new ReadLockTest();
    private static volatile int num = 0;
    public static void alwaysUseWriteLock() {
        new Thread(() -> {
            writeLock.lock();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("释放writeLock");
            writeLock.unlock();
        }).start();
    }
    public static void main(String[] args) throws InterruptedException {
        
        alwaysUseWriteLock();
        Thread.sleep(1000);
        
        new Thread(() -> {
            while (true) {
                if (readLock.tryLock()) {//尝试去获得readLock
                    System.out.println("获得readLock成功");
                    break;
                } else {
                    try {
                        Thread.sleep(1000);
                        System.out.println("获得readLock失败");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } 
            }
        }).start();
        System.out.println("main"+"线程结束");
    }

结果输出：
main线程结束
获得readLock失败
获得readLock失败
获得readLock失败
获得readLock失败
获得readLock失败
获得readLock失败
获得readLock失败
获得readLock失败
释放writeLock
获得readLock失败
获得readLock成功

从上面的输出结果可知，只要有一个线程占用了writeLock锁，其它线程要去获取readLock锁是获取不了的，如果用readLock.lock();方法去获得，程序会一直阻塞下去，直到释放wirteLock锁

    public static void alwaysUseWriteLock() {
        new Thread(() -> {
            writeLock.lock();
            System.out.println("获得writeLock锁");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("释放writeLock");
            writeLock.unlock();
        }).start();
    }
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                readLock.lock();
                System.out.println("开始执行");
                System.out.println(readLock.toString());
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("再次开始执行");
                System.out.println("开始释放锁");
                readLock.unlock();
            }).start();
        }
        Thread.sleep(1000);
        alwaysUseWriteLock();
        System.out.println("main"+"线程结束");
    }

结果输出：

开始执行
开始执行
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 9]
开始执行
开始执行
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
开始执行
开始执行
开始执行
开始执行
开始执行
开始执行
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock@13c916db[Read locks = 10]
main线程结束
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
再次开始执行
开始释放锁
获得writeLock锁
释放writeLock

由输入结果可知，一个线程要获得wirteLock锁，就必须保证其它线程都释放了readLock锁

所以

ReentrantReadWriteLock类实现了一个锁的读写分离

主要是保证程序在读数据的时候，防止其它线程中途把数据给修改了