Java并发学习(十四)-StampedLock深入浅出

Java8在concurrent.lock下新加了一个类：StampedLock，这个类和其他锁的类，都不相同。下面一起来学习下这个类。

What is StampedLock

记得在学习AtomicStampedReference 时，里面是用一个标志stamp，来解决ABA问题。即通过版本号，来检验是否保持一个相对静止的状态，从而能够保证更加线程安全的读写。具体可看：Java并发学习(十)-CAS中ABA问题解决方法 。

特性

这种锁，提供了一种新的锁，乐观读。看里面三种方式：

• 写锁，排他性，阻塞读。
• 普通读锁，对读共享，对写排他， 读少写多
• 乐观读，对读共享，对写不排他，允许写。写少读多

如果普通读的时候，可能会有这样一种情况，当读很多的时候，那就会造成获取写锁线程饥饿，一直无法获取写。
所以在StampedLock里面，就提供了一种乐观读的机制，在读的时候如果发生了写，则应当重读而不是在读的时候直接阻塞写！

这次先以一个Java doc的例子，来具体理解下StampedLock的三种锁。

Java doc的例子

/**
 * 坐标x，y，一个修改，一个读。 
 */
class Point {
   private double x, y;
   private final StampedLock sl = new StampedLock();

   void move(double deltaX, double deltaY) { 
   // 写锁，返回一个stamp
     long stamp = sl.writeLock();
     try {
       x += deltaX;
       y += deltaY;
     } finally {
     //finally块中，利用stamp，释放写锁
       sl.unlockWrite(stamp);
     }
   }

   double distanceFromOrigin() { 
   // 只读的，乐观读
     long stamp = sl.tryOptimisticRead();
     double currentX = x, currentY = y;
     //再次检验这个stamp，看是否被写锁更改
     if (!sl.validate(stamp)) {
     //更改了，那么久尝试阻塞性去获取读锁
     //所以currentX和currentY，也可能变化，重新读一遍
        stamp = sl.readLock();
        try {
          currentX = x;
          currentY = y;
        } finally {
        //用完了，释放读锁
           sl.unlockRead(stamp);
        }
     }
     //最后执行返回，可以是乐观读后的数据，或者是普通读后的数据。
     return Math.sqrt(currentX * currentX + currentY * currentY);
   }

   void moveIfAtOrigin(double newX, double newY) { 
     // Could instead start with optimistic, not read mode
     long stamp = sl.readLock();
     try {
       //没有改成功，就一直阻塞。
       while (x == 0.0 && y == 0.0) {   
       //在stamp的基础上，尝试去获取读锁。    
         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);
     }
   }
 }

如上述代码，官方的例子还是很全面的，把普通读，乐观读，写锁，以及锁转化都囊括了进去。使用起来还是很简单的。

接下来就结合源码来分析StampedLock实现机制。

StampedLock概括

先来看StampedLock的定义头：

定义：

public class StampedLock implements java.io.Serializable

如上，它并没有实现Lock或者ReadWriteLock接口，因为两个接口并不能完全满足Stamped的需求。
其次，它里面没有用到AbstractQueuedSynchronizer，但是是基于AQS这种思想的，里面也是通过一个CLH queue，来实现线程调度的，并且每一个线程用一个节点来封装，利用Unsafe的park以及unpark来进行挂起和唤醒操作，先看看WNode：

WNode：

    static final class WNode {
        volatile WNode prev;
        volatile WNode next;
        /**
         *  list of linked readers，链接这一条读锁的节点。
         */
        volatile WNode cowait;    
        /**
         * 当前线程，// non-null while possibly parked  //当被parked的时候，不为null。
         */
        volatile Thread thread;   
        /**
         * 0, WAITING, or CANCELLED   0代表等待waiting，否则是取消。
         */
        volatile int status;      
        /**
         * RMODE or WMODE   等待写还是等待读。
         */
        final int mode;           
        WNode(int m, WNode p) { mode = m; prev = p; }
    }

state变量：
先看state的定义：

/** Lock sequence/state 
     * 序列  锁的状态
     * long类型。
     * 初始值第九位为1.
     * */
    private transient volatile long state;

64位，当处于写锁状态时，第8位为1，并且普通读时，只用前7位来表示，当超出了这7位表示的数量，在用一个int类型的readerOverflow来表示读的数量。

和Lock与ReadWriteLock的转化：

 // views
    transient ReadLockView readLockView;
    transient WriteLockView writeLockView;
    transient ReadWriteLockView readWriteLockView;

如上，定义了读锁，写锁，读写锁来吧StampedLock转化为相应的锁，原理就是对StampedLock里面相应方法的封装返回，但是对于StampedLock转化要注意一下几点：

• 没有重入性质
• 没有Condition队列支持

普通读

获取锁readLock：

public long readLock() {
        long s = state, next;  // bypass acquireRead on common uncontended case
        return ((whead == wtail && (s & ABITS) < RFULL &&
                 U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
                next : acquireRead(false, 0L));
    }

首先尝试一次获取，如果获取成功，则更改state变量值，获取失败则调用acquireRead进行阻塞式获取，最终结果要么是成功获取，要么进入队列阻塞。
下面看acquireRead：

    private long acquireRead(boolean interruptible, long deadline) {
        WNode node = null, p;
        for (int spins = -1;;) {
            WNode h;
            //当whead=wtail时。
            if ((h = whead) == (p = wtail)) {
                for (long m, s, ns;;) {
                    //如果state中读锁，没有超过127，那么就在state上面更改，否则就在ReaderOverflow中更改。
                    //并且返回最终的state。
                    if ((m = (s = state) & ABITS) < RFULL ?
                        U.compareAndSwapLong(this, STATE, s, ns = s + RUNIT) :
                        (m < WBIT && (ns = tryIncReaderOverflow(s)) != 0L))
                        return ns;
                    else if (m >= WBIT) {
                        //被写着独占。来探测状态。
                        if (spins > 0) {
                            //自旋，随机减少。
                            if (LockSupport.nextSecondarySeed() >= 0)
                                --spins;
                        }
                        else {
                            if (spins == 0) {
                                //退出循环。
                                WNode nh = whead, np = wtail;
                                if ((nh == h && np == p) || (h = nh) != (p = np))
                                    break;
                            }
                            //重新设置spins，供下次使用。
                            spins = SPINS;
                        }
                    }
                }
            }
            if (p == null) { // initialize queue，初始化队列操作。
                WNode hd = new WNode(WMODE, null);
                if (U.compareAndSwapObject(this, WHEAD, null, hd))
                    wtail = hd;
            }
            else if (node == null)
                //新建一个读的node。
                node = new WNode(RMODE, p);
            else if (h == p || p.mode != RMODE) {
                if (node.prev != p)
                    node.prev = p;
                else if (U.compareAndSwapObject(this, WTAIL, p, node)) {
                    p.next = node;
                    break;
                }
            }
            else if (!U.compareAndSwapObject(p, WCOWAIT,node.cowait = p.cowait, node))
                node.cowait = null;
            else {
                //阻塞式操作，要么阻塞放入队列，要么运行。
                for (;;) {

                    WNode pp, c; Thread w;
                    if ((h = whead) != null && (c = h.cowait) != null &&
                        U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&
                        (w = c.thread) != null) // help release
                        U.unpark(w);
                    if (h == (pp = p.prev) || h == p || pp == null) {
                        long m, s, ns;
                        do {
                            //尝试再次获取，读锁。
                            if ((m = (s = state) & ABITS) < RFULL ?
                                U.compareAndSwapLong(this, STATE, s,
                                                     ns = s + RUNIT) :
                                (m < WBIT &&
                                 (ns = tryIncReaderOverflow(s)) != 0L))
                                return ns;
                        } while (m < WBIT);
                    }
                    if (whead == h && p.prev == pp) {
                        long time;
                        if (pp == null || h == p || p.status > 0) {
                            node = null; // throw away
                            break;
                        }
                        if (deadline == 0L)
                            time = 0L;
                        else if ((time = deadline - System.nanoTime()) <= 0L)
                            return cancelWaiter(node, p, false);
                        Thread wt = Thread.currentThread();
                        U.putObject(wt, PARKBLOCKER, this);
                        node.thread = wt;
                        if ((h != pp || (state & ABITS) == WBIT) &&
                            whead == h && p.prev == pp)
                            U.park(false, time);
                        node.thread = null;
                        U.putObject(wt, PARKBLOCKER, null);
                        if (interruptible && Thread.interrupted())
                            return cancelWaiter(node, p, true);
                    }
                }
            }
        }

        for (int spins = -1;;) {
            WNode h, np, pp; int ps;
            //为head，要释放后继节点。
            if ((h = whead) == p) {
                if (spins < 0)
                    spins = HEAD_SPINS;
                else if (spins < MAX_HEAD_SPINS)
                    spins <<= 1;
                for (int k = spins;;) { // spin at head，自旋，尝试去把头结点的后一个节点释放。
                    long m, s, ns;
                    if ((m = (s = state) & ABITS) < RFULL ?
                        U.compareAndSwapLong(this, STATE, s, ns = s + RUNIT) :
                        (m < WBIT && (ns = tryIncReaderOverflow(s)) != 0L)) {
                        WNode c; Thread w;
                        whead = node;
                        node.prev = null;
                        while ((c = node.cowait) != null) {
                            if (U.compareAndSwapObject(node, WCOWAIT,
                                                       c, c.cowait) &&
                                (w = c.thread) != null)
                                U.unpark(w);
                        }
                        return ns;
                    }
                    else if (m >= WBIT &&
                             LockSupport.nextSecondarySeed() >= 0 && --k <= 0)
                        break;
                }
            }
            else if (h != null) {
                WNode c; Thread w;
                while ((c = h.cowait) != null) {
                    if (U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&
                        (w = c.thread) != null)
                        U.unpark(w);
                }
            }
            if (whead == h) {
                if ((np = node.prev) != p) {
                    if (np != null)
                        (p = np).next = node;   // stale
                }
                else if ((ps = p.status) == 0)
                    U.compareAndSwapInt(p, WSTATUS, 0, WAITING);
                else if (ps == CANCELLED) {
                    if ((pp = p.prev) != null) {
                        node.prev = pp;
                        pp.next = node;
                    }
                }
                else {
                    long time;
                    if (deadline == 0L)
                        time = 0L;
                    else if ((time = deadline - System.nanoTime()) <= 0L)
                        return cancelWaiter(node, node, false);
                    Thread wt = Thread.currentThread();
                    U.putObject(wt, PARKBLOCKER, this);
                    node.thread = wt;
                    if (p.status < 0 &&
                        (p != h || (state & ABITS) == WBIT) &&
                        whead == h && node.prev == p)
                        U.park(false, time);
                    node.thread = null;
                    U.putObject(wt, PARKBLOCKER, null);
                    if (interruptible && Thread.interrupted())
                        return cancelWaiter(node, node, true);
                }
            }
        }
    }

这个方法代码有点长，就不细节一一说明，说说大概思路：

• 两个阻塞性循环，前一个自旋，做了更多初始化的相关工作，后一个是针对于头结点的自旋，如果符合要求则unpark后继节点。
• 如果最终发生中断，则需要取消获取锁，调用cancelWaiter，将node节点（即当前线程）从队列中删除，并且判断是否需要抛出异常。
• 两次循环中都会判断是否能够获取读锁：(m = (s = state) & ABITS) < RFULL 。

释放读锁unstampedUnlockRead：

 final void unstampedUnlockRead() {
        for (;;) {
            long s, m; WNode h;
            if ((m = (s = state) & ABITS) == 0L || m >= WBIT)
                throw new IllegalMonitorStateException();
            else if (m < RFULL) {
                if (U.compareAndSwapLong(this, STATE, s, s - RUNIT)) {
                    if (m == RUNIT && (h = whead) != null && h.status != 0)
                        release(h);
                    break;
                }
            }
            else if (tryDecReaderOverflow(s) != 0L)
                break;
        }
    }

以上代码判断两点，如果读锁数量超过127，即用到了readerOverflow，则在readerOverflow上修改，否则在state的低7位修改。如果需要，则调用release(h) 唤醒下一个节点。

普通写

获取写锁writeLock：

    public long writeLock() {
        long s, next;  // bypass acquireWrite in fully unlocked case only
        //如果低8位都为0，就说明没有普通读锁，也没有写锁，就尝试获取
        return ((((s = state) & ABITS) == 0L &&
                //CAS方法，尝试加上128,也就是以第8位为基点上加。然后返回这个state，也就是stamped。
                //失败进入acquireWrite
                U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
                next : acquireWrite(false, 0L));
    }

如上，通过((s = state) & ABITS) == 0L 判断是否被写锁或者普通读占据，如果没有则尝试CAS修改，没有获取到，则调用acquireWrite 进行阻塞式调用。，这里就不多说acquireWrite了，具体和acquireRead思路差不多，只是一个读锁，一个写锁，相关标志变量不同。

释放锁unstampedUnlockWrite：

 final void unstampedUnlockWrite() {
        WNode h; long s;
        if (((s = state) & WBIT) == 0L)
            throw new IllegalMonitorStateException();
        state = (s += WBIT) == 0L ? ORIGIN : s;
        if ((h = whead) != null && h.status != 0)
            release(h);
    }

如上，在释放写锁的过程中，并没有去检查是否为当前线程，只是简单了检查了state变量是否符合要求，即是否是获取状态。最后用release唤醒下一个节点进行运行。

乐观读

乐观读并没有获取锁与释放锁，它只需要获取一个状态标志，然后在检测下这个状态标志有没有被一个写锁更改，更改就尝试普通读获取锁，否则直接运行下去就可以了。

tryOptimisticRead获取状态：

  public long tryOptimisticRead() {
        long s;
        return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
    }

然后就直接进行运行，再调用validate检测是否被更改：

 public boolean validate(long stamp) {
        //禁止loadload排序。
        U.loadFence();
        //比较低7位，也就是只有读，没有写。
        return (stamp & SBITS) == (state & SBITS);
    }

当校验成功，则进行操作，如果校验失败，那么就调用普通读取重新操作rollback。具体可以结合上文那个例子进行理解。

锁转换

StampedLock里面，有锁转换这一种功能：

• tryConvertToWriteLock：转换成写锁
• tryConvertToReadLock：转换成读锁
• tryConvertToOptimisticRead：转换成乐观读锁

从里面内容的分析可以知道，在StampedLock里面，乐观读并不会对state变量执行写操作，而写锁是排他的，读锁时共享的，所以在这样一种思维下，对于锁的转化则有一个大概的认识了。就是通过判断以及写入state变量，从而改变锁的性质。
例如对于tryCoonvertToWriteLock：

    public long tryConvertToWriteLock(long stamp) {
        long a = stamp & ABITS, m, s, next;
        while (((s = state) & SBITS) == (stamp & SBITS)) {
            if ((m = s & ABITS) == 0L) {
                //检测到读锁未被占有
                if (a != 0L)
                    //读锁中途又已经被占有，那么久不能再进行获取了。
                    break;
                if (U.compareAndSwapLong(this, STATE, s, next = s + WBIT))
                    return next;
            }
            else if (m == WBIT) {
                if (a != m)
                    break;
                return stamp;
            }
            else if (m == RUNIT && a != 0L) {
                if (U.compareAndSwapLong(this, STATE, s,
                                         next = s - RUNIT + WBIT))
                    return next;
            }
            else
                break;
        }
        return 0L;
    }

如上图所示，其实大部分判断时间都会发生到if (U.compareAndSwapLong(this, STATE, s,next = s - RUNIT + WBIT))这个短路与判断里面。

接下来再简单例子：

   void moveIfAtOrigin(double newX, double newY) { // upgrade
     // Could instead start with optimistic, not read mode
     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);
     }
   }

当tryConvertToWriteLock 返回为0时，才确定已经获取成功。

参考文章：
1. jdk
2. http://blog.csdn.net/luoyuyou/article/details/30259877