JUC-StampedLock

StampedLock是JDK1.8中新增的一个读写锁，也是对ReentrantReadWriteLock的优化，乐观读，读的过程中允许获取写锁介入

stamp(戳记，long类型)，代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且当释放锁或者转换锁的时候，都要传入最初获取的stamp值

锁饥饿问题：
ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了。
假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了。
因为当前有可能会一直存在读锁，而无法获得写锁，根本没机会写。

如何缓解锁饥饿问题：

1、使用公平策略，即公平锁，new ReentrantReadWrite(true)，但是这样会降低系统吞吐量

2、使用StampedLock类的乐观读锁

ReentrantReadWriteLock
允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态。读锁和写锁也是互斥的，所以在读的时候是不允许写的，读写锁比传统的synchronized速度要快很多，原因就是在于ReentrantReadWriteLock支持读并发

StampedLock横空出世
ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。
StampedLock采取乐观获取读锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化
所以，在获取乐观读锁后，还需要对结果进行校验。

StampedLock的特点：

1、所有获取锁的方法，都返回一个邮截（Stamp），Stamp为零表示获取失败，其余都表示成功；
2、所有释放锁的方法，都需要一个邮截（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；
3、StampedLock是不可重入的（如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁）

StampedLock的三种访问模式：

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

/**
 * StampedLock的悲观读和乐观读
 */
public class StampedLockDemo
{
    static int number = 37;
    static StampedLock stampedLock = new StampedLock();

    public void write()
    {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程准备修改");
        try
        {
            number = number + 13;
        }catch (Exception e){
            e.printStackTrace();
        }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...");
        //暂停4秒钟线程
        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);
    }

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

        //1 悲观读,和ReentrantReadWriteLock一样
        /*new Thread(() -> {
            //悲观读
            resource.read();
        },"readThread").start();*/

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

        //6秒钟乐观读取resource.tryOptimisticRead()成功
        try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }*/

        //3 乐观读，失败，重新转为悲观读，重读数据一次
        new Thread(() -> {
            //乐观读
            resource.tryOptimisticRead();
        },"readThread").start();

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


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

    }
}

StampedLock的缺点：

1、StampedLock不支持重入

2、StampedLock的悲观读锁和写锁都不支持添加变量

3、使用StampedLock不要调用中断操作，即interrupt()方法

实际中不推荐使用StampedLock