死磕 java同步系列之StampedLock源码解析

本文主要是介绍死磕 java同步系列之StampedLock源码解析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

问题

（1）StampedLock是什么？

（2）StampedLock具有什么特性？

（3）StampedLock是否支持可重入？

（4）StampedLock与ReentrantReadWriteLock的对比？

简介

StampedLock是java8中新增的类，它是一个更加高效的读写锁的实现，而且它不是基于AQS来实现的，它的内部自成一片逻辑，让我们一起来学习吧。

StampedLock具有三种模式：写模式、读模式、乐观读模式。

ReentrantReadWriteLock中的读和写都是一种悲观锁的体现，StampedLock加入了一种新的模式——乐观读，它是指当乐观读时假定没有其它线程修改数据，读取完成后再检查下版本号有没有变化，没有变化就读取成功了，这种模式更适用于读多写少的场景。

使用方法

让我们通过下面的例子了解一下StampedLock三种模式的使用方法：

class Point {private double x, y;private final StampedLock sl = new StampedLock();void move(double deltaX, double deltaY) {// 获取写锁，返回一个版本号（戳）long stamp = sl.writeLock();try {x += deltaX;y += deltaY;} finally {// 释放写锁，需要传入上面获取的版本号sl.unlockWrite(stamp);}}double distanceFromOrigin() {// 乐观读long stamp = sl.tryOptimisticRead();double currentX = x, currentY = y;// 验证版本号是否有变化if (!sl.validate(stamp)) {// 版本号变了，乐观读转悲观读stamp = sl.readLock();try {// 重新读取x、y的值currentX = x;currentY = y;} finally {// 释放读锁，需要传入上面获取的版本号sl.unlockRead(stamp);}}return Math.sqrt(currentX * currentX + currentY * currentY);}void moveIfAtOrigin(double newX, double newY) {// 获取悲观读锁long stamp = sl.readLock();try {while (x == 0.0 && y == 0.0) {// 转为写锁long ws = sl.tryConvertToWriteLock(stamp);// 转换成功if (ws != 0L) {stamp = ws;x = newX;y = newY;break;}else {// 转换失败sl.unlockRead(stamp);// 获取写锁stamp = sl.writeLock();}}} finally {// 释放锁sl.unlock(stamp);}}
}

从上面的例子我们可以与ReentrantReadWriteLock进行对比：

（1）写锁的使用方式基本一对待；

（2）读锁（悲观）的使用方式可以进行升级，通过tryConvertToWriteLock()方式可以升级为写锁；

（3）乐观读锁是一种全新的方式，它假定数据没有改变，乐观读之后处理完业务逻辑再判断版本号是否有改变，如果没改变则乐观读成功，如果有改变则转化为悲观读锁重试；

下面我们一起来学习它的源码是怎么实现的。

源码分析

主要内部类

static final class WNode {// 前一个节点volatile WNode prev;// 后一个节点volatile WNode next;// 读线程所用的链表（实际是一个栈结果）volatile WNode cowait;    // list of linked readers// 阻塞的线程volatile Thread thread;   // non-null while possibly parked// 状态volatile int status;      // 0, WAITING, or CANCELLED// 读模式还是写模式final int mode;           // RMODE or WMODEWNode(int m, WNode p) { mode = m; prev = p; }
}

队列中的节点，类似于AQS队列中的节点，可以看到它组成了一个双向链表，内部维护着阻塞的线程。

主要属性

// 一堆常量
// 读线程的个数占有低7位
private static final int LG_READERS = 7;
// 读线程个数每次增加的单位
private static final long RUNIT = 1L;
// 写线程个数所在的位置
private static final long WBIT  = 1L << LG_READERS;  // 128 = 1000 0000
// 读线程个数所在的位置
private static final long RBITS = WBIT - 1L;  // 127 = 111 1111
// 最大读线程个数
private static final long RFULL = RBITS - 1L;  // 126 = 111 1110
// 读线程个数和写线程个数的掩码
private static final long ABITS = RBITS | WBIT;  // 255 = 1111 1111
// 读线程个数的反数，高25位全部为1
private static final long SBITS = ~RBITS;  // -128 = 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1000 0000// state的初始值
private static final long ORIGIN = WBIT << 1;  // 256 = 1 0000 0000
// 队列的头节点
private transient volatile WNode whead;
// 队列的尾节点
private transient volatile WNode wtail;
// 存储着当前的版本号，类似于AQS的状态变量state
private transient volatile long state;

通过属性可以看到，这是一个类似于AQS的结构，内部同样维护着一个状态变量state和一个CLH队列。

构造方法

public StampedLock() {state = ORIGIN;
}

state的初始值为ORIGIN（256），它的二进制是 1 0000 0000，也就是初始版本号。

writeLock()方法

获取写锁。

public long writeLock() {long s, next;// ABITS = 255 = 1111 1111// WBITS = 128 = 1000 0000// state与ABITS如果等于0，尝试原子更新state的值加WBITS// 如果成功则返回更新的值，如果失败调用acquireWrite()方法return ((((s = state) & ABITS) == 0L &&U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?next : acquireWrite(false, 0L));
}

我们以state等于初始值为例，则state & ABITS的结果为：

此时state为初始状态，与ABITS与运算后的值为0，所以执行后面的CAS方法，s + WBITS的值为384 = 1 1000 0000。

到这里我们大胆猜测：state的高24位存储的是版本号，低8位存储的是是否有加锁，第8位存储的是写锁，低7位存储的是读锁被获取的次数，而且如果只有第8位存储写锁的话，那么写锁只能被获取一次，也就不可能重入了。

到底我们猜测的对不对呢，走着瞧^^

我们接着来分析acquireWrite()方法：

（手机横屏看源码更方便）

private long acquireWrite(boolean interruptible, long deadline) {// node为新增节点，p为尾节点（即将成为node的前置节点）WNode node = null, p;// 第一次自旋——入队for (int spins = -1;;) { // spin while enqueuinglong m, s, ns;// 再次尝试获取写锁if ((m = (s = state) & ABITS) == 0L) {if (U.compareAndSwapLong(this, STATE, s, ns = s + WBIT))return ns;}

这篇关于死磕 java同步系列之StampedLock源码解析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---