深入理解StampedLock及其实现原理

最新推荐文章于 2024-07-28 17:38:56 发布
最新推荐文章于 2024-07-28 17:38:56 发布
阅读量579 收藏 1
点赞数
文章标签： java 数据结构与算法
本文深入探讨了StampedLock的实现原理，包括其三种模式（写入、读取、乐观读取）的工作机制，以及如何在不同模式之间转换。重点分析了读锁和写锁的获取与释放流程，包括自旋、随机等待、队列管理和状态检查等方面，同时揭示了不可中断锁获取操作中的问题。最后，通过实例代码展示了StampedLock在维护二维空间点操作中的应用。
摘要由CSDN通过智能技术生成

背景（注释）：

一个基于容量并且带有三种模式的锁，用于控制读取/写入访问。StampedLock的状态由版本和模式组成。锁获取操作返回一个用于展示和访问锁状态的邮编（stamp）变量：这些方法的"try"版本通过返回0代表获取锁失败。锁释放以及其他相关方法需要使用邮编（stamps）变量作为参数，如果他们和当前锁状态不符则失败，这三种模式为：

 

  • 写入：方法writeLock可能为了获取独占访问而阻塞当前线程，返回一个邮编变量，能够在unlockWrite方法中使用从而释放锁。限时和立即版本的tryWriteLock也提供了支持。当锁被写模式所占有，没有读或者乐观的读操作能够成功。
  • 读取：方法readLock可能为了获取非独占访问而阻塞当前线程，返回一个邮编变量，能够在unlockRead方法中用于释放锁。限时和立即版本的tryReadLock也提供了支持。
  • 乐观读取：是方法tryOptimisticRead返回一个非0邮编变量，仅在当前锁没有以写入模式被持有。方法validate返回true如果在获得邮编变量（stamp）之后没有被写模式持有。这种模式可以被看做一种弱版本的读锁，可以被一个写入者在任何时间打断。乐观读取模式仅用于短时间读取操作时经常能够降低竞争和提高吞吐量。当然，它的使用在本质上是脆弱的。乐观读取的区域应该只包括字段，并且在validation之后用局部变量持有它们从而在后续使用。乐观模式下读取的字段值很可能是非常不一致的，所以它应该只用于那些你熟悉如何展示数据，从而你可以不断检查一致性和调用方法validate。比如，当我们第一次读取对象或者数组引用，然后检查它的字段、元素以及方法时。
 
这个类支持在模式之间转化的方法。比如，方法tryConvertToWriteLock尝试“升级”模式，返回一个合理的写入邮编，假如（1）已经是写模式（2）读模式，但是没有更多的读取者（3）处于乐观模式并且这个锁可能被获取。这些方法的形式被设计成有助于降低代码膨胀，特别是基于重试的设计。
 
StampedLocks被设计成在线程安全组件发展过程中的一个内部支持工具。他们的使用依赖于所要保护的数据、对象以及方法的内部性质。他们不是重入的，所以获取锁之后的操作里面不应该包括未知的会再次获取锁的操作（虽然你把stamp传递给其他方法能够使用或者转化它）。读模式锁的使用必须确保相关的代码块是无副作用的。未验证的乐观读区域不能调用那些无法容忍潜在不一致的方法。stamp变量使用有限的形式，并且没有安全加密（一个正确的stamp能够被猜出来）。邮编变量可能（不会更久）会在一年的连续操作之后回溯。一个stamp没有使用或者验证，那么在很长一段时间之后可能就会验证失败。StampedLocks是序列化的，但是通过反序列化为初始的非锁定状态，所以在远程锁定中是不安全的。
 
StampedLock的调度策略没有给读提供优先，写也一样。所有"try“的方法尽最大努力，但是不需要遵循任何调度或者公平策略。从"try“中返回0无法说明关于状态state的任何信息。一个接下来的调用可能会成功。
因为通过协作的方式支持多种模式，所以这个类没有直接实现Lock或者ReadWriteLock方法。当然，一个StampedLock可以通过asReadLock，asWriteLock，asReadWriteLock方法来得到全部功能的子集。
 
使用场景：
接下来这个类中的例子维护了一个二维空间的点。这个样例代码说明了一些try/catch使用管理，虽然他们不需要在此使用，因为没有异常会在代码体中出现：
 
[java]  view plain  copy
 
  1. class Point {  
  2.   private double x, y;  
  3.   private final StampedLock sl = new StampedLock();  
  4.   
  5.   void move(double deltaX, double deltaY) { // an exclusively locked method  
  6.     long stamp = sl.writeLock();  
  7.     try {  
  8.       x += deltaX;  
  9.       y += deltaY;  
  10.     } finally {  
  11.       sl.unlockWrite(stamp);  
  12.     }  
  13.   }  
  14.   
  15.   double distanceFromOrigin() { // A read-only method  
  16.     long stamp = sl.tryOptimisticRead();  
  17.     double currentX = x, currentY = y;  
  18.     if (!sl.validate(stamp)) {  
  19.        stamp = sl.readLock();  
  20.        try {  
  21.          currentX = x;  
  22.          currentY = y;  
  23.        } finally {  
  24.           sl.unlockRead(stamp);  
  25.        }  
  26.     }  
  27.     return Math.sqrt(currentX * currentX + currentY * currentY);  
  28.   }  
  29.   
  30.   void moveIfAtOrigin(double newX, double newY) { // upgrade  
  31.     // Could instead start with optimistic, not read mode  
  32.     long stamp = sl.readLock();  
  33.     try {  
  34.       while (x == 0.0 && y == 0.0) {  
  35.         long ws = sl.tryConvertToWriteLock(stamp);  
  36.         if (ws != 0L) {  
  37.           stamp = ws;  
  38.           x = newX;  
  39.           y = newY;  
  40.           break;  
  41.         }  
  42.         else {  
  43.           sl.unlockRead(stamp);  
  44.           stamp = sl.writeLock();  
  45.         }  
  46.       }  
  47.     } finally {  
  48.       sl.unlock(stamp);  
  49.     }  
  50.   }  
  51. }  

算法（注释）：
 
从概念上说，这个锁的主要状态包含一个序列数，当处于写模式时第8位为1，读模式时前7为为1-126（附加的readerOverflow用于当读者超过126时）。当然，具体的读取个数是被忽略的当我们验证”乐观"序列锁-读者-方式 邮编时。因为我们必须使用一个足够小的数字（7位）来处理读者，所以一个提供补充的值被使用，在我们的读者数量超过了使用的位数。我们通过使用最大的读者个数（RBITS）作为一个自旋保护机制来做在溢出值上做更新。
 
等待者使用了一个CLH锁的变化形式，CLH在AbstractQueuedSynchronizer 中使用，每一个节点作为一个读者或者写者来等待。读者的集合通过一个公共节点被聚集在一起，所以通过单个节点来附加到CLH队列上。凭借队列的结构，等待者节点不能使用序列数。我们知道每一个是大于他们的前驱。这样可以简化FIFO队列的主要调度策略，通过引入了阶段-公平锁。特别的，我们使用阶段-公平（phase-fair）规则：如果一个读取到来时返现有一个写入等待，这个读取会入队。（这个规则使得acquireRead增加了一些复杂性，否则使得这个锁非常不公平），方法释放不会（不能）通过自身来唤醒等待者。这个责任是通过主线程，但是可以通过其他线程来协助，比如在方法acquireRead和acquireWirte中。
 
这些规则适用于已经入队的线程。所有的tryLock形式的方法试着获取锁而不管其他的优先规则，所以可能导致队列中的线程没有获取成功（因为闯入的线程获取了锁）。随机的自旋使用（增加开销）能够降低上下文切换，当我们为了避免线程间持续的内存颠簸。我们限制了自旋操作仅用于队列的头元素。一个线程会自旋等待SPINS次（每次都有50%的机会递减自旋值）在阻塞前。如果线程觉醒后还是没有获得锁，并且仍然是第一个等待线程（其他线程闯入并且获取了锁），那么它便会增加自己的自旋次数从而降低被闯入的线程获得锁的可能。
 
序列检查（主要是validate方法）需要严格的内存排序，在读取操作上（“state”）。我们通过使用Unsafe.loadFence来强制读取操作和验证操作在一些情况下的内存排序问题。
当前的内存布局保证了状态变量state和队列指针一起（在同一个缓存行上）。这样使得读取频繁的负载下工作良好。在大多数其他情况，CLH队列的自然属性以及它的自适应自旋，能够通过扩展竞争位置的方式从而降低内存竞争，在将来可能会作出改善。
 
实现：
 
首先我们来看读取锁的实现：
[java]  view plain  copy
 
  1. public long readLock() {  
  2.     long s = state, next;  // bypass acquireRead on common uncontended case  
  3.     return ((whead == wtail && (s & ABITS) < RFULL &&  
  4.              U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?  
  5.             next : acquireRead(false, 0L));  
  6. }  
[java]  view plain  copy
 
  1. private long acquireRead(boolean interruptible, long deadline) {  
  2.     WNode node = null, p;  
  3.     for (int spins = -1;;) {  
  4.         WNode h;  
  5.         if ((h = whead) == (p = wtail)) {  
  6.             for (long m, s, ns;;) {  
  7.                 if ((m = (s = state) & ABITS) < RFULL ?  
  8.                     U.compareAndSwapLong(this, STATE, s, ns = s + RUNIT) :  
  9.                     (m < WBIT && (ns = tryIncReaderOverflow(s)) != 0L))  
  10.                     return ns;  
  11.                 else if (m >= WBIT) {  
  12.                     if (spins > 0) {  
  13.                         if (LockSupport.nextSecondarySeed() >= 0)  
  14.                             --spins;  
  15.                     }  
  16.                     else {  
  17.                         if (spins == 0) {  
  18.                             WNode nh = whead, np = wtail;  
  19.                             if ((nh == h && np == p) || (h = nh) != (p = np))  
  20.                                 break;  
  21.                         }  
  22.                         spins = SPINS;  
  23.                     }  
  24.                 }  
  25.             }  
  26.         }  
  27.         if (p == null) { // initialize queue  
  28.             WNode hd = new WNode(WMODE, null);  
  29.             if (U.compareAndSwapObject(this, WHEAD, null, hd))  
  30.                 wtail = hd;  
  31.         }  
  32.         else if (node == null)  
  33.             node = new WNode(RMODE, p);  
  34.         else if (h == p || p.mode != RMODE) {  
  35.             if (node.prev != p)  
  36.                 node.prev = p;  
  37.             else if (U.compareAndSwapObject(this, WTAIL, p, node)) {  
  38.                 p.next = node;  
  39.                 break;  
  40.             }  
  41.         }  
  42.         else if (!U.compareAndSwapObject(p, WCOWAIT,  
  43.                                          node.cowait = p.cowait, node))  
  44.             node.cowait = null;  
  45.         else {  
  46.             for (;;) {  
  47.                 WNode pp, c; Thread w;  
  48.                 if ((h = whead) != null && (c = h.cowait) != null &&  
  49.                     U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&  
  50.                     (w = c.thread) != null) // help release  
  51.                     U.unpark(w);  
  52.                 if (h == (pp = p.prev) || h == p || pp == null) {  
  53.                     long m, s, ns;  
  54.                     do {  
  55.                         if ((m = (s = state) & ABITS) < RFULL ?  
  56.                             U.compareAndSwapLong(this, STATE, s,  
  57.                                                  ns = s + RUNIT) :  
  58.                             (m < WBIT &&  
  59.                              (ns = tryIncReaderOverflow(s)) != 0L))  
  60.                             return ns;  
  61.                     } while (m < WBIT);  
  62.                 }  
  63.                 if (whead == h && p.prev == pp) {  
  64.                     long time;  
  65.                     if (pp == null || h == p || p.status > 0) {  
  66.                         node = null; // throw away  
  67.                         break;  
  68.                     }  
  69.                     if (deadline == 0L)  
  70.                         time = 0L;  
  71.                     else if ((time = deadline - System.nanoTime()) <= 0L)  
  72.                         return cancelWaiter(node, p, false);  
  73.                     Thread wt = Thread.currentThread();  
  74.                     U.putObject(wt, PARKBLOCKER, this);  
  75.                     node.thread = wt;  
  76.                     if ((h != pp || (state & ABITS) == WBIT) &&  
  77.                         whead == h && p.prev == pp)  
  78.                         U.park(false, time);  
  79.                     node.thread = null;  
  80.                     U.putObject(wt, PARKBLOCKER, null);  
  81.                     if (interruptible && Thread.interrupted())  
  82.                         return cancelWaiter(node, p, true);  
  83.                 }  
  84.             }  
  85.         }  
  86.     }  
  87.   
  88.     for (int spins = -1;;) {  
  89.         WNode h, np, pp; int ps;  
  90.         if ((h = whead) == p) {  
  91.             if (spins < 0)  
  92.                 spins = HEAD_SPINS;  
  93.             else if (spins < MAX_HEAD_SPINS)  
  94.                 spins <<= 1;  
  95.             for (int k = spins;;) { // spin at head  
  96.                 long m, s, ns;  
  97.                 if ((m = (s = state) & ABITS) < RFULL ?  
  98.                     U.compareAndSwapLong(this, STATE, s, ns = s + RUNIT) :  
  99.                     (m < WBIT && (ns = tryIncReaderOverflow(s)) != 0L)) {  
  100.                     WNode c; Thread w;  
  101.                     whead = node;  
  102.                     node.prev = null;  
  103.                     while ((c = node.cowait) != null) {  
  104.                         if (U.compareAndSwapObject(node, WCOWAIT,  
  105.                                                    c, c.cowait) &&  
  106.                             (w = c.thread) != null)  
  107.                             U.unpark(w);  
  108.                     }  
  109.                     return ns;  
  110.                 }  
  111.                 else if (m >= WBIT &&  
  112.                          LockSupport.nextSecondarySeed() >= 0 && --k <= 0)  
  113.                     break;  
  114.             }  
  115.         }  
  116.         else if (h != null) {  
  117.             WNode c; Thread w;  
  118.             while ((c = h.cowait) != null) {  
  119.                 if (U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&  
  120.                     (w = c.thread) != null)  
  121.                     U.unpark(w);  
  122.             }  
  123.         }  
  124.         if (whead == h) {  
  125.             if ((np = node.prev) != p) {  
  126.                 if (np != null)  
  127.                     (p = np).next = node;   // stale  
  128.             }  
  129.             else if ((ps = p.status) == 0)  
  130.                 U.compareAndSwapInt(p, WSTATUS, 0, WAITING);  
  131.             else if (ps == CANCELLED) {  
  132.                 if ((pp = p.prev) != null) {  
  133.                     node.prev = pp;  
  134.                     pp.next = node;  
  135.                 }  
  136.             }  
  137.             else {  
  138.                 long time;  
  139.                 if (deadline == 0L)  
  140.                     time = 0L;  
  141.                 else if ((time = deadline - System.nanoTime()) <= 0L)  
  142.                     return cancelWaiter(node, node, false);  
  143.                 Thread wt = Thread.currentThread();  
  144.                 U.putObject(wt, PARKBLOCKER, this);  
  145.                 node.thread = wt;  
  146.                 if (p.status < 0 &&  
  147.                     (p != h || (state & ABITS) == WBIT) &&  
  148.                     whead == h && node.prev == p)  
  149.                     U.park(false, time);  
  150.                 node.thread = null;  
  151.                 U.putObject(wt, PARKBLOCKER, null);  
  152.                 if (interruptible && Thread.interrupted())  
  153.                     return cancelWaiter(node, node, true);  
  154.             }  
  155.         }  
  156.     }  
  157. }  
这里的readLock会首先尝试直接CAS改变state（在whead==wtail和(s & ABITS) < RFULL的情况下），成功的话直接返回stamp（next）。
竞争失败的情况下进入acquireRead的逻辑，下面详细分析acquireRead的逻辑（至今为止最长的代码块）：
  • 传入的两参数：interruptible和deadline，前者标识是否允许中断，后者标识超时限时（0代表不限时），然后进入循环。
  • 首先取得whead和wtail两个值，假如这两个值不等说明已经又入队者了，那么获取读锁没希望了。
  • 否则再进入内层循环，会尽力尝试通过前7bit上递增state来获取锁 ，这里采取的方式极具特色，采用了另一个readerOverflow了计数另外增加的读者数量，state的前七位记录到126之后就会稳定在这个值，偶尔会到127，但是超出126的部分最终到了readerOverflow，加入获取了锁就返回stamp。
  • 假如m >= WBIT，也就是说m（state前8位）值大于或等于128，那么说明当前锁已经被写者独占，那么我们尝试自旋+随机的方式来探测状态，并且在当前队列和进入循环前一样（说明还没有其他入队者）或者当前队列中已经有了入队者的情况下内层循环跳出，接着肯定会入队。
  • 首先根据尾节点为null的情况探测是否初始化队列，使用一个WMODE模式的节点初始化whead和wtail。
  • 然后假如当前节点为空则构建当前节点，模式为RMODE，前驱节点为p即尾节点。
  • 接着查看，假如当前队列为空即只有一个节点（whead=wtail）或者当前尾节点的模式不是RMODE，那么我们会尝试在尾节点后面添加该节点作为尾节点，然后跳出外层循环；假如当前队列不为空并且当前尾节点模式就是RMODE，那么我们会尝试下一步：添加该节点到尾节点的cowait链（实际上构成一个stack）中。
我们先来分析处于同一循环中的后一种情况：尾节点模式为RMODE：
  • 通过CAS方法将该节点node添加至尾节点的cowait链中，node成为cowait中的顶元素，cowait构成了一个LIFO队列。
  • 成功后进入另一个循环，首先尝试unpark头元素（whead）的cowait中的第一个元素，这只是一种辅助作用，因为头元素whead所伴随的那个线程（假如存在）必定是已经获得锁了，假如是读锁那么也必定会释放cowait链。
  • 假如当前节点node所在的根节点p的前驱就是whead或者p已经是whead或者p的前驱为null，那么我们会根据state再次积极的尝试获取锁（当m < WBIT）。
  • 否则我们探测当前队列是否稳定：whead == h && p.prev == pp，在稳定的情况下，假如发现p成为过head或者p已经被取消（status>0），我们尝试node=null，并且跳出当前循环，回到一开的循环里面去尝试获取锁（这样做的原因是被其他线程闯入夺取了锁，或者p已经被取消）。
  • 接着我们判断是否为限时版本，以及限时版本所需时间。
  • 然后park当前线程以及可能出现的中断情况下取消当前节点的cancelWaiter操作。
我们再来分析跳出循环的另一种情况：队列中无节点或者尾节点模式为WMODE：这样我们的节点必须直接拼接到尾节点后面。
  • 这样p作为当前节点的前驱节点，假如正好是whead的话，那么会尝试自旋+随机的方式在积极得探测state，从而能够取得锁。并且在获得锁，重置whead和node.prev=null之后释放当前cowait链中的节点。最后返回stamp。
  • 否则只需h不为null时尝试释放当前头节点的cowait链，作为一种协作的积极行动。
  • 然后在whead==h即队列稳定时，首先会CAS操作当前节点前驱的status，从0变为WAITING从而指示后面有等待的节点。假如发现p的状态已经为取消了，则重新选择node的前驱。
  • 前面的这些都处理完成之后，使用类似的park以及cancelWaiter操作。区别在于这里的p.status<0必须保证（因为等待状态WAITING是-1）。
 
我们接着来看写入锁的实现：
 
[java]  view plain  copy
 
  1. public long writeLock() {  
  2.     long s, next;  // bypass acquireWrite in fully unlocked case only  
  3.     return ((((s = state) & ABITS) == 0L &&  
  4.              U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?  
  5.             next : acquireWrite(false, 0L));  
  6. }  
[java]  view plain  copy
 
  1. private long acquireWrite(boolean interruptible, long deadline) {  
  2.     WNode node = null, p;  
  3.     for (int spins = -1;;) { // spin while enqueuing  
  4.         long m, s, ns;  
  5.         if ((m = (s = state) & ABITS) == 0L) {  
  6.             if (U.compareAndSwapLong(this, STATE, s, ns = s + WBIT))  
  7.                 return ns;  
  8.         }  
  9.         else if (spins < 0)  
  10.             spins = (m == WBIT && wtail == whead) ? SPINS : 0;  
  11.         else if (spins > 0) {  
  12.             if (LockSupport.nextSecondarySeed() >= 0)  
  13.                 --spins;  
  14.         }  
  15.         else if ((p = wtail) == null) { // initialize queue  
  16.             WNode hd = new WNode(WMODE, null);  
  17.             if (U.compareAndSwapObject(this, WHEAD, null, hd))  
  18.                 wtail = hd;  
  19.         }  
  20.         else if (node == null)  
  21.             node = new WNode(WMODE, p);  
  22.         else if (node.prev != p)  
  23.             node.prev = p;  
  24.         else if (U.compareAndSwapObject(this, WTAIL, p, node)) {  
  25.             p.next = node;  
  26.             break;  
  27.         }  
  28.     }  
  29.   
  30.     for (int spins = -1;;) {  
  31.         WNode h, np, pp; int ps;  
  32.         if ((h = whead) == p) {  
  33.             if (spins < 0)  
  34.                 spins = HEAD_SPINS;  
  35.             else if (spins < MAX_HEAD_SPINS)  
  36.                 spins <<= 1;  
  37.             for (int k = spins;;) { // spin at head  
  38.                 long s, ns;  
  39.                 if (((s = state) & ABITS) == 0L) {  
  40.                     if (U.compareAndSwapLong(this, STATE, s,  
  41.                                              ns = s + WBIT)) {  
  42.                         whead = node;  
  43.                         node.prev = null;  
  44.                         return ns;  
  45.                     }  
  46.                 }  
  47.                 else if (LockSupport.nextSecondarySeed() >= 0 &&  
  48.                          --k <= 0)  
  49.                     break;  
  50.             }  
  51.         }  
  52.         else if (h != null) { // help release stale waiters  
  53.             WNode c; Thread w;  
  54.             while ((c = h.cowait) != null) {  
  55.                 if (U.compareAndSwapObject(h, WCOWAIT, c, c.cowait) &&  
  56.                     (w = c.thread) != null)  
  57.                     U.unpark(w);  
  58.             }  
  59.         }  
  60.         if (whead == h) {  
  61.             if ((np = node.prev) != p) {  
  62.                 if (np != null)  
  63.                     (p = np).next = node;   // stale  
  64.             }  
  65.             else if ((ps = p.status) == 0)  
  66.                 U.compareAndSwapInt(p, WSTATUS, 0, WAITING);  
  67.             else if (ps == CANCELLED) {  
  68.                 if ((pp = p.prev) != null) {  
  69.                     node.prev = pp;  
  70.                     pp.next = node;  
  71.                 }  
  72.             }  
  73.             else {  
  74.                 long time; // 0 argument to park means no timeout  
  75.                 if (deadline == 0L)  
  76.                     time = 0L;  
  77.                 else if ((time = deadline - System.nanoTime()) <= 0L)  
  78.                     return cancelWaiter(node, node, false);  
  79.                 Thread wt = Thread.currentThread();  
  80.                 U.putObject(wt, PARKBLOCKER, this);  
  81.                 node.thread = wt;  
  82.                 if (p.status < 0 && (p != h || (state & ABITS) != 0L) &&  
  83.                     whead == h && node.prev == p)  
  84.                     U.park(false, time);  // emulate LockSupport.park  
  85.                 node.thread = null;  
  86.                 U.putObject(wt, PARKBLOCKER, null);  
  87.                 if (interruptible && Thread.interrupted())  
  88.                     return cancelWaiter(node, node, true);  
  89.             }  
  90.         }  
  91.     }  
  92. }  
 
可以看到获取写入锁时不需要顾及当前队列是否有元素，可以直接“闯入”从而获得锁。
  • 这里同样是以自旋+随机的方式来探测锁，只不过探测值变为了m = (s = state) & ABITS) == 0L。
  • 之后的过程同样是初始化队列，构造节点，设置前驱，拼接节点（对于写入锁只有在队列尾部拼接一种选择）。
  • 这之后的操作事实上和读取锁中的根节点的操作类似，都是会先积极尝试自旋在whead节点上，然后清理头结点，以及前驱的被取消节点，最后才park住。
接着我们来看会在限时和中断的取消操作：
[java]  view plain  copy
 
  1. private long cancelWaiter(WNode node, WNode group, boolean interrupted) {  
  2.     if (node != null && group != null) {  
  3.         Thread w;  
  4.         node.status = CANCELLED;  
  5.         // unsplice cancelled nodes from group  
  6.         for (WNode p = group, q; (q = p.cowait) != null;) {  
  7.             if (q.status == CANCELLED) {  
  8.                 U.compareAndSwapObject(p, WCOWAIT, q, q.cowait);  
  9.                 p = group; // restart  
  10.             }  
  11.             else  
  12.                 p = q;  
  13.         }  
  14.         if (group == node) {  
  15.             for (WNode r = group.cowait; r != null; r = r.cowait) {  
  16.                 if ((w = r.thread) != null)  
  17.                     U.unpark(w);       // wake up uncancelled co-waiters  
  18.             }  
  19.             for (WNode pred = node.prev; pred != null; ) { // unsplice  
  20.                 WNode succ, pp;        // find valid successor  
  21.                 while ((succ = node.next) == null ||  
  22.                        succ.status == CANCELLED) {  
  23.                     WNode q = null;    // find successor the slow way  
  24.                     for (WNode t = wtail; t != null && t != node; t = t.prev)  
  25.                         if (t.status != CANCELLED)  
  26.                             q = t;     // don't link if succ cancelled  
  27.                     if (succ == q ||   // ensure accurate successor  
  28.                         U.compareAndSwapObject(node, WNEXT,  
  29.                                                succ, succ = q)) {  
  30.                         if (succ == null && node == wtail)  
  31.                             U.compareAndSwapObject(this, WTAIL, node, pred);  
  32.                         break;  
  33.                     }  
  34.                 }  
  35.                 if (pred.next == node) // unsplice pred link  
  36.                     U.compareAndSwapObject(pred, WNEXT, node, succ);  
  37.                 if (succ != null && (w = succ.thread) != null) {  
  38.                     succ.thread = null;  
  39.                     U.unpark(w);       // wake up succ to observe new pred  
  40.                 }  
  41.                 if (pred.status != CANCELLED || (pp = pred.prev) == null)  
  42.                     break;  
  43.                 node.prev = pp;        // repeat if new pred wrong/cancelled  
  44.                 U.compareAndSwapObject(pp, WNEXT, pred, succ);  
  45.                 pred = pp;  
  46.             }  
  47.         }  
  48.     }  
  49.     WNode h; // Possibly release first waiter  
  50.     while ((h = whead) != null) {  
  51.         long s; WNode q; // similar to release() but check eligibility  
  52.         if ((q = h.next) == null || q.status == CANCELLED) {  
  53.             for (WNode t = wtail; t != null && t != h; t = t.prev)  
  54.                 if (t.status <= 0)  
  55.                     q = t;  
  56.         }  
  57.         if (h == whead) {  
  58.             if (q != null && h.status == 0 &&  
  59.                 ((s = state) & ABITS) != WBIT && // waiter is eligible  
  60.                 (s == 0L || q.mode == RMODE))  
  61.                 release(h);  
  62.             break;  
  63.         }  
  64.     }  
  65.     return (interrupted || Thread.interrupted()) ? INTERRUPTED : 0L;  
  66. }  

这里三个参数， node：需要删除的节点、group：可能的聚合节点、interrupted：是否被中断。
详情如下：
  • 首先设置node的状态为CANCELLED，可以向其他线程传递这个节点是删除了的信息。
  • 然后再聚合节点gruop上清理所有状态为CANCELLED的节点（即删除节点）
  • 接下来假如当期node节点本身就是聚合节点，那么首先唤醒cowait链中的所有节点（读者），寻找到node后面的第一个非CANCELLED节点，直接拼接到pred上（从而删除当前节点），然后再检查前驱节点状态，假如为CANCELLED则需也需要重置前驱节点。
  • 最后，在队列中不为空，并且头结点的状态为0即队列中的节点还未设置WAITING信号&当前没有持有写入锁模式&（当前没有锁或者只有乐观锁 | 队列中第一个等待者为读模式），那么就从队列头唤醒一次。
 
存在的问题：
  • 不可中断的锁获取操作中没有保存中断状态，造成CPU占有。
  • 由于新型锁使用了新的数据结构，所以当读锁的第一个节点被中断取消时，它的cowait链接上的节点会全部重新拼接到队列上，这样会造成一定程序的"优先级反转"。具体可用如下方法再现：
为了更好得看出这个问题，将源码中造成随机性的LockSupport.nextSecondarySeed取消掉。
然后协调取锁的限时，并使用类似如下代码：
[java]  view plain  copy
 
  1.     public static void main(String[] args) throws InterruptedException{  
  2.         // TODO Auto-generated method stub  
  3.         StampedLock lock = new StampedLock();  
  4.         new Thread(new WriteThread(lock)).start();  
  5. //        new Thread(new ReadThreadTry(lock)).start();  
  6.         Thread.sleep(200);  
  7.         new Thread(new ReadThreadTry(lock)).start();  
  8.         Thread.sleep(100);  
  9. //        new Thread(new ReadThreadTry(lock)).start();  
  10.         for( int i = 0; i < 6; ++i)  
  11.             new Thread(new ReadThread(lock)).start();  
  12.         Thread.sleep(300);  
  13.         for( int i = 0; i < 6; ++i)  
  14.             new Thread(new WriteThreadLast(lock)).start();  
  15.     }  
[java]  view plain  copy
 
  1.     public static void main(String[] args) throws InterruptedException{  
  2.         // TODO Auto-generated method stub  
  3.         StampedLock lock = new StampedLock();  
  4.         new Thread(new WriteThread(lock)).start();  
  5. //        new Thread(new ReadThreadTry(lock)).start();  
  6.         Thread.sleep(200);  
  7.         new Thread(new ReadThread(lock)).start();  
  8.         Thread.sleep(100);  
  9.         new Thread(new ReadThreadTry(lock)).start();  
  10.         for( int i = 0; i < 5; ++i)  
  11.             new Thread(new ReadThread(lock)).start();  
  12.         Thread.sleep(300);  
  13.         for( int i = 0; i < 6; ++i)  
  14.             new Thread(new WriteThreadLast(lock)).start();  
  15.     }  
[java]  view plain  copy
 
  1. private static class WriteThread implements Runnable{  
  2.     private StampedLock lock;  
  3.     public WriteThread(StampedLock lock){  
  4.         this.lock = lock;  
  5.     }  
  6.       
  7.     public void run(){  
  8.         long writeLong = lock.writeLock();  
  9.         System.out.println(Thread.currentThread().getName() + " WRITE");  
  10.         try {  
  11.             Thread.sleep(1000);  
  12.         } catch (InterruptedException e) {  
  13.             // TODO Auto-generated catch block  
  14.             e.printStackTrace();  
  15.         }  
  16.         lock.unlockWrite(writeLong);  
  17.     }  
  18. }  
  19.   
  20. private static class ReadThreadTry implements Runnable{  
  21.     private StampedLock lock;  
  22.     public ReadThreadTry(StampedLock lock){  
  23.         this.lock = lock;  
  24.     }  
  25.       
  26.     public void run(){  
  27.         long readLong = 0;  
  28.         try {  
  29.             readLong = lock.tryReadLock(600, TimeUnit.MILLISECONDS);  
  30.             if(readLong  > 0)  
  31.                 System.out.println(Thread.currentThread().getName() + " READ LOCK");  
  32.             else  
  33.                 System.out.println(Thread.currentThread().getName() + " READ noLOCK");  
  34.         } catch (InterruptedException e) {  
  35.             // TODO Auto-generated catch block  
  36.             e.printStackTrace();  
  37.         }finally{  
  38.             if(readLong>0)  
  39.                 lock.unlockRead(readLong);  
  40.         }  
  41.     }  
  42. }  
  43.   
  44. private static class ReadThread implements Runnable{  
  45.     private StampedLock lock;  
  46.     public ReadThread(StampedLock lock){  
  47.         this.lock = lock;  
  48.     }  
  49.       
  50.     public void run(){  
  51.         long readLong = lock.readLock();  
  52.         System.out.println(Thread.currentThread().getName() + " READ");  
  53.         lock.unlockRead(readLong);  
  54.     }  
  55. }  
  56.   
  57. private static class WriteThreadLast implements Runnable{  
  58.     private StampedLock lock;  
  59.     public WriteThreadLast(StampedLock lock){  
  60.         this.lock = lock;  
  61.     }  
  62.       
  63.     public void run(){  
  64.         long writeLong = lock.writeLock();  
  65.         System.out.println(Thread.currentThread().getName() + " WRITE");  
  66.         lock.unlockWrite(writeLong);  
  67.     }  
  68. }  


观察输出信息，就可以看出问题。
weixin_33800593
关注
Java互联网架构多线程并发编程原理及实战 视频教程 下载.zip
06-18
3-4 深入理解synchronized.mp4 3-5 volatile关键字及其使用场景.mp4 3-6 单例与线程安全.mp4 3-7 如何避免线程安全性问题.mp4 4-1 锁的分类.mp4 4-2 深入理解Lock接口.mp4 4-3 实现属于自己的锁.mp4 4-4 ...
StampedLock实现原理
曲终人散
11-10 523
一 1 基于CLH锁->一种自旋锁，保证没有饥饿发生，FIFO顺序【先进先出】 2 维护一个线程队列，申请不成功的记录在此，每个节点保存一个标记位【locked】，用来判断当前线程是否释放锁 3 当线程试图获取锁，取得当前队列的尾部节点作为其前序节点，并使用类似while(pred.locked){}判断前序节点是否已经成功释放锁 4 只要前序节点没有释放锁，则表示当前线程还不能继续执行，自旋等待。 5 如果前序线程已经释放，则当前线程可以继续执行 6 释放锁时线程将自己的节点标记位置为false，那
StampedLock原理分析
breakout_alex的博客
12-08 1161
背景 ReentrantReadWriteLock可以让多个读线程同时持有读锁（只要写锁未被占用），而写锁是独占的，所以在读多写少的场景上可以提高吞吐量，比如hdfs文件系统。但是，读写锁如果使用不当，很容易产生“饥饿”问题，比如在读线程非常多，写线程很少的情况下，很容易导致写线程“饥饿”，虽然使用“公平”策略可以一定程度上缓解这个问题，但是“公平”策略是以牺牲系统吞吐量为代价的。 导致写线程饥饿的情况：当线程 A 持有读锁读取数据时，线程 B 要获取写锁修改数据就只能到队列里排队。此时又来了线程 C
StampedLock原理及使用
cisco_huang的博客
02-17 2270
JDK1.8之前, 锁已经那么多了, 为什么还要有StampedLock? 一般应用, 都是读多写少, ReentrantReadWriteLock 因读写互斥, 故读时阻塞写, 因而性能上上不去。 可能会使线程饥饿 官方代码例子 public class StampedLockDemo { // 成员变量 private double x, y; // 锁实例 ...
Java并发编程--锁原理之StampedLock锁
一个巨大的博客
01-23 433
文章目录JDK 8 中新增的StampedLock锁的原理(1). 概述(2). 写锁writeLock(3). 悲观读readLock(4). 乐观读OptimisticRead()(5). 锁转换(6). 使用乐观读锁 JDK 8 中新增的StampedLock锁的原理 (1). 概述 ​  StampedLock锁是并发包中JDK 8版本新增的一个锁,提供了三种模式的读写控制.当调用try...
AQS源码解析之StampedLock的实现原理
StampedLock是Java 8中引入的一种新型锁机制，它提供了一种乐观读锁的实现方式，能够在某些场景下比传统的读写锁更高效地使用。StampedLock的设计目标是在多线程环境下提供更好的并发性能，特别适用于读多写少的场景...
Java集合框架深入解析：从原理到应用，全面理解集合框架，高效管理数据
它提供了一个统一的接口和丰富的实现类，简化了数据操作，提高了代码的可读性和可维护性。 集合框架的核心是**集合接口**，定义了集合操作的基本行为，如添加、删除和检索元素。这些接口包括List、Set和Map，它们...
【框架机制探索】：深入理解主流框架中Java Semaphore的运用之道
[【框架机制探索】：深入理解主流框架中Java Semaphore的运用之道](https://static001.geekbang.org/infoq/f6/f63f97c7002b42ab717c1ff3602c3257.webp) # 1. Java Semaphore概述 ## 1.1 Semaphore简介 Java ...
【源码揭秘】：Java Atomic类内部实现原理及最佳实践
[【源码揭秘】：Java Atomic类内部实现原理及最佳实践](https://opengraph.githubassets.com/89370175eb0c23a8c1d9b8efa66823ad6c3850a673f57dfdc15688cf4a7a00d4/CoffeeBeforeArch/spinlocks) # 1. Java Atomic类...
详解-StampedLock原理-并发编程(Java)
gaogzhen的博客
01-04 532
详解-StampedLock原理-并发编程(Java)
聊聊java中的StampedLock并发锁原理
zjj2006的专栏
07-25 530
StampedLock的使用和原理
StampedLock 应用及原理详解
键盘上流淌的日子
06-23 8233
  从synchronized到ReentrantLock，从ReentrantLock到ReentrantReadWriteLock，都在尽量减少锁带来的负面影响。   · synchronized：语言级别支持，使用简单，但缺少灵活性，且不可中断。   · ReentrantLock：JUC提供，使用相对复杂，但是可灵活控制锁的获得和释放，可中断。   · ReentrantReadWriteLock：实现了锁的分离，分为读锁和写锁，写写、写读互斥，读读可并发使用。   虽然synchronized、R
StampedLock详解
最新发布
落日的博客
07-28 1506
是JUC并发包里面 JDK8 版本新增的一个锁，是读写锁的一种具体实现，和不同的是其不提供可重入性，不基于某个类似Lock或者ReadWriteLock接口实现,而是基于CLH锁思想实现这点这AQS有些类似，并且StampedLock不支持条件变量Condition。关于可以参考上篇文章 ReentrantReadWriteLock详解。那么JDK既然实现了这个锁，就说明这个锁一定有优势，那就是性能优势，下面会具体分析。
StampedLock浅析（一）
sinat_33472737的博客
03-30 405
一种基于功能的锁，具有三种模式来控制读/写访问。 StampedLock的状态由版本和模式组成。 锁获取方法返回一个戳记（stamp），表示锁状态的访问控制； 这些方法的“尝试”版本可能会返回特殊值零，以表示无法获取访问权限。 锁释放和转换方法需要使用戳记作为参数，如果它们与锁的状态不匹配，则会失败。 三种模式是： 写。方法writeLock可能会阻塞以等待独占访问，返回可以在方法unlockWrite使用的戳记stamp以释放锁。还提供了tryWriteLock不定时版本和定时版本。 当锁保持在写
StampedLock（印戳锁）详解
CodePanda@GPF的博客
04-10 3461
StampedLock、印戳锁
Java 8新特性探究（十）StampedLock将是解决同步问题的新宠
weixin_33701251的博客
05-13 369
2019独角兽企业重金招聘Python工程师标准>>> ...
StampedLock
07-16
StampedLock 是 Java 8 引入的一种新的锁机制，它是 ReentrantReadWriteLock 的改进版本，提供了更高级别的并发控制。 StampedLock 主要有三种模式：读模式、写模式和乐观读模式。 1. 读模式（Read Mode）：多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值