1.   前面介绍的ReadWriteLock可以解决多线程同时读，但只有一个线程能写的问题。如果我们深入分析ReadWriteLock，会发现它有个潜在的问题：如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，即读的过程中不允许写，这是一种悲观的读锁。即有我没它，有它没我。<br />      为了进一步提升并发执行效率，Java 8引入了新的读写锁：StampedLock。它和ReadWriteLock相比，改进之处在于：但是，在Optimistic reading（三种模式之一）中，即使读线程获取到了读锁，写线程尝试获取写锁也不会阻塞，这相当于对读模式的优化，但是可能会导致数据不一致的问题。所以，当使用Optimistic reading获取到读锁时，必须对获取结果进行校验。显然乐观读锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。

StampedLock的特点

StampedLock的主要特点概括一下，有以下几点：

  1. 所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为0表示获取失败，其余都表示成功；
  2. 所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；
  3. StampedLock是不可重入的；（如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁）
  4. StampedLock有三种访问模式：
    ①Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似
    ②Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
    ③Optimistic reading（乐观读模式）：这是一种优化的读模式。
  5. StampedLock支持读锁和写锁的相互转换
    我们知道RRW中，当线程获取到写锁后，可以降级为读锁，但是读锁是不能直接升级为写锁的。
    StampedLock提供了读锁和写锁相互转换的功能，使得该类支持更多的应用场景。
  6. 无论写锁还是读锁，都不支持Conditon等待

先来看一个Oracle官方的例子：

  1. package com.example.customers.humm.thread.stampedLock;
  3. import java.util.concurrent.locks.StampedLock;
  5. public class StampedLockDemo {
  7.     private final StampedLock stampedLock = new StampedLock();
  9.     private double x;
  10.     private double y;
  12.     public void move(double deltaX, double deltaY) {
  13.         long stamp = stampedLock.writeLock(); // 获取写锁
  14.         try {
  15.             x += deltaX;
  16.             y += deltaY;
  17.         } finally {
  18.             stampedLock.unlockWrite(stamp); // 释放写锁
  19.         }
  20.     }
  22.     public double distanceFromOrigin() {
  23.         long stamp = stampedLock.tryOptimisticRead(); // 获得一个乐观读锁
  24.         // 注意下面两行代码不是原子操作
  25.         // 假设x,y = (100,200)
  26.         double currentX = x;
  27.         // 此处已读取到x=100，但x,y可能被写线程修改为(300,400)
  28.         double currentY = y;
  29.         // 此处已读取到y，如果没有写入，读取是正确的(100,200)
  30.         // 如果有写入，读取是错误的(100,400)
  31.         if (!stampedLock.validate(stamp)) { // 检查乐观读锁后是否有其他写锁发生
  32.             stamp = stampedLock.readLock(); // 获取一个悲观读锁
  33.             try {
  34.                 currentX = x;
  35.                 currentY = y;
  36.             } finally {
  37.                 stampedLock.unlockRead(stamp); // 释放悲观读锁
  38.             }
  39.         }
  40.         return Math.sqrt(currentX * currentX + currentY * currentY);
  41.     }
  44. }
  1.   上述示例最特殊的其实是distanceFromOrigin方法，这个方法中使用了“Optimistic reading”乐观读锁，使得读写可以并发执行，但是“Optimistic reading”的使用必须遵循以下模式：
  1. long stamp = lock.tryOptimisticRead();  // 非阻塞获取版本信息
  2. copyVaraibale2ThreadMemory();           // 拷贝变量到线程本地堆栈
  3. if(!lock.validate(stamp)){              // 校验
  4.     long stamp = lock.readLock();       // 获取读锁
  5.     try {
  6.         copyVaraibale2ThreadMemory();   // 拷贝变量到线程本地堆栈
  7.      } finally {
  8.        lock.unlock(stamp);              // 释放悲观锁
  9.     }
  11. }
  12. useThreadMemoryVarables();              // 使用线程本地堆栈里面的数据进行操作
  1.   和ReadWriteLock相比，写入的加锁是完全一样的，不同的是读取。注意到首先我们通过tryOptimisticRead()获取一个乐观读锁，并返回版本号。接着进行读取，读取完成后，我们通过validate()去验证版本号，如果在读取过程中没有写入，版本号不变，验证成功，我们就可以放心地继续后续操作。如果在读取过程中有写入，版本号会发生变化，验证将失败。在失败的时候，我们再通过获取悲观读锁再次读取。由于写入的概率不高，程序在绝大部分情况下可以通过乐观读锁获取数据，极少数情况下使用悲观读锁获取数据。<br />      可见，StampedLock把读锁细分为乐观读和悲观读，能进一步提升并发效率。但这也是有代价的：一是代码更加复杂，二是StampedLock是不可重入锁，不能在一个线程中反复获取同一个锁。StampedLock还提供了更复杂的将悲观读锁升级为写锁的功能，它主要使用在if-then-update的场景：即先读，如果读的数据满足条件，就返回，如果读的数据不满足条件，再尝试写。<br />      StampedLock提供了乐观读锁，可取代ReadWriteLock以进一步提升并发性能；StampedLock是不可重入锁。可以看到。

三、StampedLock原理

待学习！！

转载自：https://segmentfault.com/a/1190000015808032?utm_source=tag-newest#item-4