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();
        }
    }
}