十九、读写锁和邮戳锁

一、读写锁ReentrantReadWriteLock

1、基本概念

读写锁ReentrantReadWriteLock，一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程。它并不是真正意义上的读写分离，它只允许读读共存，而读写和写写依然是互斥的。

一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁。当读锁被使用时，如果有线程尝试获取写锁，该写线程会被阻塞。所以，需要释放所有读锁，才可获取写锁。

使用场景

只有在读多写少情境之下，读写锁才具有较高的性能体现。

缺点

1、锁饥饿，写的线程一直抢不到锁。

2、读的过程中，如果没有释放，写线程不可以获得锁。必须读完后，才能有机会写。

Demo

public class ReentrantReadWriteLockDemo {
    public static void main(String[] args) {
        MyTest myTest = new MyTest();
        //  写线程
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myTest.write(finalI, finalI);
            }, String.valueOf(i)).start();
        }
        //  读线程
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            new Thread(() -> {
                myTest.read(finalI, finalI);
            }, String.valueOf(i)).start();
        }
    }
}

class MyTest {
    Map map = new HashMap();
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void write(int key, int value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " -- 正在写入");
            //  暂停1s线程
            try {
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " -- 完成写入");
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void read(int key, int value) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " -- 正在读取");
            //  暂停2s线程
            try {
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " -- 完成读取");
        } finally {
            lock.readLock().unlock();
        }
    }
}

输出：

2、ReentrantReadWriteLock降级规则

锁降级，遵循获取写锁 -> 获取读锁 -> 再释放写锁的次序，写锁能够降级成为读锁，无法从读锁定升级到写锁的。

目的

锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性，后续线程可以继续获取到读锁。

Demo

public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {        
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
        ReentrantReadWriteLock.ReadLock readLock = lock.readLock();

        //  有且只有一个线程main，来验证锁降级策略要求
        writeLock.lock();
        System.out.println("writeLock-lock");

        readLock.lock();
        System.out.println("readLock");

        writeLock.unlock();
        System.out.println("writeLock-------unlock");
    }
} 

 输出：

writeLock-lock
readLock
writeLock-------unlock

二、邮戳锁StampedLock

为了解决读写锁的锁饥饿的问题而诞生，读的过程中也允许获取写锁介入。ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，所以，在获取乐观读后后，还需要对结果进行校验。

特点：

（1）所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为零表示获取失败，其余都表示成功；

（2）所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；

（3）StampedLock是不可重入的，危险（如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁）。

（4）三种访问模式：

　　①Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似。

　　②Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似。

　　③Optimistic reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式。

缺点：

（1）StampedLock 不支持重入，没有Re开头。

（2）StampedLock 的悲观读锁和写锁都不支持条件变量（Condition），这个也需要注意。

（3）使用 StampedLock一定不要调用中断操作，即不要调用interrupt() 方法。

Demo：

public class StampedLockDemo {
    static int number = 37;
    static StampedLock stampedLock = new StampedLock();

    public static void main(String[] args) {
        StampedLockDemo resource = new StampedLockDemo();

        new Thread(() -> {
            //  乐观读
            resource.tryOptimisticRead();
        }, "readThread").start();

        //  2秒钟时乐观读失败
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            resource.write();
        }, "writeThread").start();
    }

    /**
     * 写入
     */
    public void write() {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName() + "\t" + "===写线程准备修改");
        try {
            number = number + 13;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "===写线程修改结束");
    }

    /**
     * 悲观读
     */
    public void read() {
        long stamp = stampedLock.readLock();
        System.out.println(Thread.currentThread().getName() + "\t come in readlock block,4 seconds continue...");
        //暂停几秒钟线程
        for (int i = 0; i < 4; i++) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t 正在读取中......");
        }
        try {
            int result = number;
            System.out.println(Thread.currentThread().getName() + "\t" + " 获得成员变量值result：" + result);
            System.out.println("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

    /**
     * 乐观读
     */
    public void tryOptimisticRead() {
        long stamp = stampedLock.tryOptimisticRead();
        //  先把数据获取一次
        int result = number;
        //  间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，实际靠判断。
        System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)" + "\t" + stampedLock.validate(stamp));
        for (int i = 1; i <= 4; i++) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t 正在读取中......" + i +
                    "秒后stampedLock.validate值(true无修改，false有修改)" + "\t"
                    + stampedLock.validate(stamp));
        }
        //  判断数据是否被修改过
        if (!stampedLock.validate(stamp)) {
            System.out.println("有人动过--------存在写操作！");
            stamp = stampedLock.readLock();
            try {
                System.out.println("从乐观读 升级为 悲观读");
                result = number;
                System.out.println("重新悲观读锁通过获取到的成员变量值result：" + result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        //  输出最终结果
        System.out.println(Thread.currentThread().getName() + "\t finally value: " + result);
    }
}