Visitar URL original
在多线程开发中，为了控制线程同步，使用的最多的莫过于synchronized 关键字和重入锁。在JDK8中，又引入了一款新式武器StampedLock。这是一个什么东西呢？英文单词Stamp，意思是邮戳。那在这里有用什么含义呢？傻瓜，请看下面的分解。
面对临界区资源管理的问题，大体上有2套思路：
第一就是使用悲观的策略，悲观者这样认为：在每一次访问临界区的共享变量，总是有人会和我冲突，因此，每次访问我必须先锁住整个对象，完成访问后再解锁。
而与之相反的乐天派却认为，虽然临界区的共享变量会冲突，但是冲突应该是小概率事件，大部分情况下，应该不会发生，所以，我可以先访问了再说，如果等我用完了数据还没人冲突，那么我的操作就是成功；如果我使用完成后，发现有人冲突，那么我要么再重试一次，要么切换为悲观的策略。
从这里不难看到，重入锁以及synchronized 是一种典型的悲观策略。聪明的你一定也猜到了，StampedLock就是提供了一种乐观锁的工具，因此，它是对重入锁的一个重要的补充。
在StampedLock的文档中就提供了一个非常好的例子，让我们可以很快的理解StampedLock的使用。下面让我看一下这个例子，有关它的说明，都写在注释中了。
这里再说明一下validate()方法的含义，函数签名长这样：
public boolean validate(long stamp)
它的接受参数是上次锁操作返回的邮戳，如果在调用validate()之前，这个锁没有写锁申请过，那就返回true，这也表示锁保护的共享数据并没有被修改，因此之前的读取操作是肯定能保证数据完整性和一致性的。
反之，如果锁在validate()之前有写锁申请成功过，那就表示，之前的数据读取和写操作冲突了，程序需要进行重试，或者升级为悲观锁。
从上面的例子其实不难看到，就编程复杂度来说，StampedLock其实是要比重入锁复杂的多，代码也没有以前那么简洁了。
那么，我们为什么还要使用它呢？
最本质的原因，就是为了提升性能！一般来说，这种乐观锁的性能要比普通的重入锁快几倍，而且随着线程数量的不断增加，性能的差距会越来越大。
简而言之，在大量并发的场景中StampedLock的性能是碾压重入锁和读写锁的。
但毕竟，世界上没有十全十美的东西，StampedLock也并非全能，它的缺点如下：
如果以上3点对你来说都不是问题，那么我相信StampedLock应该成为你的首选。
为了帮助大家更好的理解StampedLock，这里再简单给大家介绍一下它的内部实现和数据结构。
在StampedLock中，有一个队列，里面存放着等待在锁上的线程。该队列是一个链表，链表中的元素是一个叫做WNode的对象：
当队列中有若干个线程等待时，整个队列可能看起来像这样的：
除了这个等待队列，StampedLock中另外一个特别重要的字段就是long state， 这是一个64位的整数，StampedLock对它的使用是非常巧妙的。
state 的初始值是:
private static final int LG_READERS = 7;
private static final long WBIT = 1L << LG_READERS;
private static final long ORIGIN = WBIT << 1;
也就是 ...0001 0000 0000 (前面的0太多了，不写了，凑足64个吧~)，为什么这里不用0做初始值呢？因为0有特殊的含义，为了避免冲突，所以选择了一个非零的数字。
如果有写锁占用，那么就让第7位设置为1 ...0001 1000 0000，也就是加上WBIT。
每次释放写锁，就加1，但不是state直接加，而是去掉最后一个字节，只使用前面的7个字节做统计。因此，释放写锁后，state就变成了：...0010 0000 0000， 再加一次锁，又变成：...0010 1000 0000，以此类推。
这里为什么要记录写锁释放的次数呢？
这是因为整个state 的状态判断都是基于CAS操作的。而普通的CAS操作可能会遇到ABA的问题，如果不记录次数，那么当写锁释放掉，申请到，再释放掉时，我们将无法判断数据是否被写过。而这里记录了释放的次数，因此出现"释放->申请->释放"的时候，CAS操作就可以检查到数据的变化，从而判断写操作已经有发生，作为一个乐观锁来说，就可以准确判断冲突已经产生，剩下的就是交给应用来解决冲突即可。因此，这里记录释放锁的次数，是为了精确地监控线程冲突。
而state剩下的那一个字节的其中7位，用来记录读锁的线程数量，由于只有7位，因此只能记录可怜的126个,看下面代码中的RFULL，就是读线程满载的数量。超过了怎么办呢，多余的部分就记录在readerOverflow字段中。
private static final long WBIT = 1L << LG_READERS;
private static final long RBITS = WBIT - 1L;
private static final long RFULL = RBITS - 1L;
private transient int readerOverflow;
总结一下，state变量的结构如下：
在了解了StampedLock的内部数据结构之后，让我们再来看一下有关写锁的申请和释放吧！首先是写锁的申请：
public long writeLock() {
long s, next;
return ((((s = state) & ABITS) == 0L && //有没有读写锁被占用，如果没有，就设置上写锁标记
U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
//如果写锁占用成功范围next，如果失败就进入acquireWrite()进行锁的占用。
next : acquireWrite(false, 0L));
}
如果CAS设置state失败，表示写锁申请失败，这时，会调用acquireWrite()进行申请或者等待。acquireWrite()大体做了下面几件事情：
wtail == whead， 表示快轮到我了，所以进行自旋等待，抢到就结束了wtail==null ，说明队列都没初始化，就初始化一下队列(h = whead) == p), 那说明也快轮到我了，不断进行自旋等待争抢简单地说，acquireWrite()函数就是用来争抢锁的，它的返回值就是代表当前锁状态的邮戳，同时，为了提高锁的性能，acquireWrite()使用大量的自旋重试，因此，它的代码看起来有点晦涩难懂。
写锁的释放如下所示，unlockWrite()的传入参数是申请锁时得到的邮戳：
public void unlockWrite(long stamp) {
WNode h;
//检查锁的状态是否正常
if (state != stamp || (stamp & WBIT) == 0L)
throw new IllegalMonitorStateException();
// 设置state中标志位为0，同时也起到了增加释放锁次数的作用
state = (stamp += WBIT) == 0L ? ORIGIN : stamp;
// 头结点不为空，尝试唤醒后续的线程
if ((h = whead) != null && h.status != 0)
//唤醒(unpark)后续的一个线程
release(h);
}
获取读锁的代码如下：
public long readLock() {
long s = state, next;
//如果队列中没有写锁，并且读线程个数没有超过126，直接获得锁，并且读线程数量加1
return ((whead == wtail && (s & ABITS) < RFULL &&
U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
//如果争抢失败，进入acquireRead()争抢或者等待
next : acquireRead(false, 0L));
}
acquireRead()的实现相当复杂，大体上分为这么几步：
总之，就是自旋，自旋再自旋，通过不断的自旋来尽可能避免线程被真的挂起，只有当自旋充分失败后，才会真正让线程去等待。
下面是释放读锁的过程：
StampedLock固然是个好东西，但是由于它特别复杂，难免也会出现一些小问题。下面这个例子，就演示了StampedLock悲观锁疯狂占用CPU的问题：
public class StampedLockTest {
public static void main(String[] args) throws InterruptedException {
final StampedLock lock = new StampedLock();
Thread t1 = new Thread(() -> {
// 获取写锁
lock.writeLock();
// 模拟程序阻塞等待其他资源
LockSupport.park();
});
t1.start();
// 保证t1获取写锁
Thread.sleep(100);
Thread t2 = new Thread(() -> {
// 阻塞在悲观读锁
lock.readLock();
});
t2.start();
// 保证t2阻塞在读锁
Thread.sleep(100);
// 中断线程t2,会导致线程t2所在CPU飙升
t2.interrupt();
t2.join();
}
}
上述代码中，在中断t2后，t2的CPU占用率就会沾满100%。而这时候，t2正阻塞在readLock()函数上，换言之，在受到中断后，StampedLock的读锁有可能会占满CPU。这是什么原因呢？机制的小傻瓜一定想到了，这是因为StampedLock内太多的自旋引起的！没错，你的猜测是正确的。
具体原因如下：
如果没有中断，那么阻塞在readLock()上的线程在经过几次自旋后，会进入park()等待，一旦进入park()等待，就不会占用CPU了。但是park()这个函数有一个特点，就是一旦线程被中断，park()就会立即返回，返回还不算，它也不给你抛点异常啥的，那这就尴尬了。本来呢，你是想在锁准备好的时候，unpark()的线程的，但是现在锁没好，你直接中断了，park()也返回了，但是，毕竟锁没好，所以就又去自旋了。
转着转着，又转到了park()函数，但悲催的是，线程的中断标记一直打开着，park()就阻塞不住了，于是乎，下一个自旋又开始了，没完没了的自旋停不下来了，所以CPU就爆满了。
要解决这个问题，本质上需要在StampedLock内部，在park()返回时，需要判断中断标记为，并作出正确的处理，比如，退出，抛异常，或者把中断位给清理一下，都可以解决问题。
但很不幸，至少在JDK8里，还没有这样的处理。因此就出现了上面的，中断readLock()后，CPU爆满的问题。请大家一定要注意。
今天，我们比较仔细地介绍了StampedLock的使用和主要实现思想，StampedLock是一种重入锁和读写锁的重要补充。
它提供了一种乐观锁的策略，是一种与众不同的锁实现。当然了，就编程难度而言，StampedLock会比重入锁和读写锁稍微繁琐一点，但带来的却是性能的成倍提升。
这里给大家提一些小意见，如果我们的应用线程数量可控，并且不多，竞争不太激烈，那么就可以直接使用简单的synchronized,重入锁，读写锁就好了；如果应用线程数量多，竞争激烈，并且对性能敏感，那么还是需要我们劳神费力，用一下比较复杂的StampedLock，来提高一下程序的吞吐量。
使用StampedLock还需要特别注意两点：第一StampedLock不是可重入的，千万不要单线程自己和自己搞死锁了，第二，StampedLock没有等待/通知机制，如果一定需要这个功能的话，也只能绕行啦！
小傻瓜们对这个冷门类是否有深一步的理解了？理解了可以在评论区来一波：变得更强
我是敖丙，你知道的越多，不知道的越多，我们下期见。