独占锁和共享锁，读锁和写锁
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 { 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 加完之后 1Thread-1加一结束，开始睡2秒---------------------------Thread-0开始加一上次的值是 1 加完之后 2Thread-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 { 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 { 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类实现了一个锁的读写分离
主要是保证程序在读数据的时候，防止其它线程中途把数据给修改了