Java8 StampedLock（一） 源码解析

 目录

一、定义

二、使用

1、读写锁

2、锁重入

3、非公平锁 

4、乐观读锁

5、锁转换

---

StampedLock是Java8引入的，对ReentrantReadWriteLock的一个改良和扩展，其底层实现不再基于AbstractQueuedSynchronizer了，本篇博客就来详细探讨该类的定义和使用。

一、定义

    StampedLock没有直接实现ReadWriteLock，但是提供了方法可以返回ReadWriteLock接口的实现类，如下：

可以通过asReadWriteLock方法与之前使用ReentrantReadWriteLock无缝兼容，也可以通过asReadLock和asWriteLock方法单独使用读锁或者写锁。

    StampedLock定义了多个内部类，如下：

ReadLockView和WriteLockView都实现了Lock接口，前者用于实现读锁，asReadLock方法就返回该类的实例；后者用于实现写锁，asWriteLock就返回该类的实例；ReadWriteLockView实现了ReadWriteLock接口，asReadWriteLock接口就返回该类的实例。这三个类的实现基于StampedLock的public方法的。如下：

 注意ReadLockView和WriteLockView的newCondition方法的实现都是抛出UnsupportedOperationException异常，因为StampedLock提供Condition接口的实现类，不过正常使用Condition接口都是直接使用ReentrantLock。

上面的WNode和AbstractQueuedSynchronizer的内部类Node基本一样，其定义如下：

Node中使用nextWaiter属性来记录锁的模式，这里单列了一个字段mode；status属性对应于Node中的waitStatus属性，cowait属性用来构成一个等待获取读锁的WNode链表，通过遍历这个链表就可以获取在此节点之后请求读锁的所有线程，避免遍历同步链表时判断是否读锁节点；其他三个字段和Node中的含义一样。

 StampedLock中定义了多个常量，如下：

    /**CPU的个数，用来判断自旋次数*/
    private static final int NCPU = Runtime.getRuntime().availableProcessors();

    /** 加入等待链表前自旋的最大次数，如果是多核，则最多自旋64次 */
    private static final int SPINS = (NCPU > 1) ? 1 << 6 : 0;

    /** 等待head节点释放锁时第一轮for循环自旋（自旋通过内层的for循环实现）的最大次数，如果是多核，则最多自旋1024次
        如果还是无法获取锁，则进入第二轮for循环，自旋的最大次数扩容一倍，直到达到 
        MAX_HEAD_SPINS为止不再扩容   */
    private static final int HEAD_SPINS = (NCPU > 1) ? 1 << 10 : 0;

    /** 等待head节点释放锁时一轮for循环自旋的最大次数，则最多自旋65536次 */
    private static final int MAX_HEAD_SPINS = (NCPU > 1) ? 1 << 16 : 0;

    /** 执行yeild的周期 */
    private static final int OVERFLOW_YIELD_RATE = 7; // must be power 2 - 1

    /** 用来记录读锁重入次数的位数，第7位之后的位用来记录累计获取写锁的次数 */
    private static final int LG_READERS = 7;

    //获取读锁成功后state加上RUNIT 
    private static final long RUNIT = 1L;
    //获取写锁和释放写锁成功后需要将state加上WBIT，然后通过第8位的位是否为1判断是否占有写锁
    private static final long WBIT  = 1L << LG_READERS;
    //RBITS表示重入读锁的理论最大次数了，就是7个1，即127
    private static final long RBITS = WBIT - 1L;
    //实际允许重入读锁的最大次数，即126
    private static final long RFULL = RBITS - 1L;
    //ABITS就是8个1，将state与之求且，如果结果为0则表示此时读锁和写锁都没有被占用
    //如果结果大于WBIT，即第8位为1，表示写锁被占有了
    //如果结果等于RFULL则说明读锁重入的次数达到最大值了，多余次数通过readerOverflow属性记录
    private static final long ABITS = RBITS | WBIT;
    //前57位是1，后7位是0，将state与之求且可以获取获取写锁的累计次数
    private static final long SBITS = ~RBITS; // note overlap with ABITS

    //初始值
    private static final long ORIGIN = WBIT << 1;

    //线程被中断后返回的特殊值 
    private static final long INTERRUPTED = 1L;

    //WNode节点的状态，初始是0
    private static final int WAITING   = -1;
    private static final int CANCELLED =  1;

    //读锁和写锁对应的模式
    private static final int RMODE = 0;
    private static final int WMODE = 1;

StampedLock包含的实例属性如下：

     /** 同步链表头 */
    private transient volatile WNode whead;
    /** 同步链表尾 */
    private transient volatile WNode wtail;

    // 实现读写锁接口的实例
    transient ReadLockView readLockView;
    transient WriteLockView writeLockView;
    transient ReadWriteLockView readWriteLockView;

    /** 记录锁的状态 */
    private transient volatile long state;
    /** 读锁重入次数达到最大值后，记录超过最大值的次数*/
    private transient int readerOverflow;

StampedLock包含的静态属性都是通过static代码块初始化，都是些关键属性的偏移量，用来实现原子的修改属性值，如下：

二、使用

1、读写锁

      StampedLock本身是为了优化ReentrantReadWriteLock的性能，其用法完全跟后者保持一致，可以借用后者的测试用例，如下：

 @Test
    public void test() throws Exception {
        StampedLock lock=new StampedLock();
        Lock readLock=lock.asReadLock();
        CyclicBarrier cyclicBarrier=new CyclicBarrier(6);
        Runnable a=new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    readLock.lock();
                    Thread.sleep(1000);
                    System.out.println("do something end for read,time->"+System.currentTimeMillis());
                    cyclicBarrier.await();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    readLock.unlock();
                }

            }
        };
        for(int i=0;i<5;i++){
            new Thread(a).start();
        }
        long start=System.currentTimeMillis();
        cyclicBarrier.await();
        System.out.println("read end,time->"+(System.currentTimeMillis()-start));
        Lock writeLock=lock.asWriteLock();
        Runnable b=new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    writeLock.lock();
                    Thread.sleep(1000);
                    System.out.println("do something end for write,time->"+System.currentTimeMillis());
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    writeLock.unlock();
                    try {
                        cyclicBarrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        };
        for(int i=0;i<5;i++){
            new Thread(b).start();
        }
        start=System.currentTimeMillis();
        cyclicBarrier.await();
        System.out.println("write end,time->"+(System.currentTimeMillis()-start));
    }

    @Test
    public void test2() throws Exception {
        StampedLock lock=new StampedLock();
        Lock readLock=lock.asReadLock();
        Lock writeLock=lock.asWriteLock();
        CountDownLatch writeCount=new CountDownLatch(5);
        Runnable a=new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
                try {
                    readLock.lock();
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread()