8.读写锁ReadWriteLock

/*ReadWriteLock 读写锁*/

private ReadWriteLock lock = new ReentrantReadWriteLock();

lock.readLock().lock();  　　lock.writeLock().lock();

ReadWriteLock 维护了 /*一对*/ 相关的锁，一个用于只读操作，另一个用于写入操作

只要没有writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的

ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须是独占的方式来获取锁。对于读取操作占多数的数据结构。

ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作

 /*
  * 1.ReadWriterLock ： 读写锁
  *
  * 写写 /读写 需要 “互斥”
  * 读读 不需要互斥
  * */

 public class TestReadWriteLock {

     public static void main(String[] args) {
         //匿名内部类 使用外部的参数 需要加上 final （1.8之后就不需要了 ，但是也不能修改）
         //这和外部参数的生命周期有关
          final ReadWriteLockThread lt = new ReadWriteLockThread();

         //创建一个 ‘写’ 线程
         new Thread(new Runnable() {
             @Override
             public void run() {
                 lt.write(10);
             }
         },"write").start();

         ////创建100个 ‘读’ 线程
         for(int i = 0;i<100;i++) {

             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     lt.read();
                 }
             },"read").start();
         }
     }
 }
 class ReadWriteLockThread {
     private int number = 1;
     private ReadWriteLock lock = new ReentrantReadWriteLock();

     public void read() {
         lock.readLock().lock();
         try {
             System.out.println(number);
         } finally {
             lock.readLock().unlock();
         }

     }

     public void write(int number) {
         lock.writeLock().lock();
         try {
             System.out.println(this.number);
             this.number = number;
         } finally {
             lock.writeLock().unlock();
         }
     }
 }