线程同步——读写锁

当没有锁的时候，多个线程会出现共抢临界资源的情况，导致一方还未读取输出，另一方抢先修改了结果，从而使得输出结果不正确。

但是，多个线程访问，如果仅仅是【读】操作，并不会对结果产生影响，而【写】操作则会使运行结果出现错误。

ReadWriteLock接口：可以实现多个读线程同时读取数据，写线程需要互斥执行，提高效率。
【读 / 写 、写 / 写】需要互斥，【读 / 读】不需要互斥

相关方法

/**
* 构造方法
*/
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
ReadWriteLock lock=new ReentrantReadWriteLock();

/**
* 普通方法，与ReentrantLock方法使用一致，需要上锁，然后try-finally，在finally里释放锁
*/
lock.writeLock().lock();
lock.writeLock().unlock();
lock.readLock().lock();
lock.readLock().unlock();

方法案例
写入锁修改数值，读取锁直接读取数值

/**
* 数值类
*/
public class Res {
    private int num;
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
}

/**
* 测试类【重点】
*/
public class Test {
    public static void main(String[] args) {
        //共享资源
        Res res = new Res();
        //创建读写锁
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        //写入
        Runnable runnable = new Runnable() {
            public void run() {
                lock.writeLock().lock();
                try {
                    int n = new Random().nextInt(1000);	//随机获取1000以内数
                    res.setNum(n);	//修改数值
                    System.out.println(Thread.currentThread().getName() + "写入" + n);
                } finally {
                    lock.writeLock().unlock();
                }
            }
        };
        //读取（共享锁）
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                lock.readLock().lock();
                try {
                    int num = res.getNum();
                    System.out.println(Thread.currentThread().getName() + "读取" + num);
                } finally {
                    lock.readLock().unlock();
                }
            }
        };

        //写线程，写写，读写，互斥，所以必然每次只能进入一个
        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }

        //读线程，读读不互斥，所以可能100个线程都会同时读
        //从而提高效率，写限制，而读不限制
        for (int i = 0; i < 100; i++) {
            new Thread(runnable1).start();
        }
    }
}

如果进行睡眠定时，会发现，写操作运行时间较慢，完全按照设定的时间进行，而读操作的100循环几乎同时跳出结果。