死磕 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 WMODE
    WNode(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 enqueuing
        long m, s, ns;
        // 再次尝试获取写锁
        if ((m = (s = state) & ABITS) == 0L) {
   
            if (U.compareAndSwapLong(this, STATE, s, ns = s + WBIT))
                return ns;
        }