面对临界区资源管理的问题,大体上有2套思路:
第一就是使用悲观的策略,悲观者这样认为:在每一次访问临界区的共享变量,总是有人会和我冲突,因此,每次访问我必须先锁住整个对象,完成访问后再解锁。
而与之相反的乐天派却认为,虽然临界区的共享变量会冲突,但是冲突应该是小概率事件,大部分情况下,应该不会发生,所以,我可以先访问了再说,如果等我用完了数据还没人冲突,那么我的操作就是成功;如果我使用完成后,发现有人冲突,那么我要么再重试一次,要么切换为悲观的策略。
从这里不难看到,重入锁以及synchronized 是一种典型的悲观策略。聪明的你一定也猜到了,StampedLock就是提供了一种乐观锁的工具,因此,它是对重入锁的一个重要的补充。
StampedLock的基本使用
在StampedLock的文档中就提供了一个非常好的例子,让我们可以很快的理解StampedLock的使用。下面让我看一下这个例子,有关它的说明,都写在注释中了。
这里再说明一下validate()方法的含义,函数签名长这样:
- public boolean validate(long stamp)
它的接受参数是上次锁操作返回的邮戳,如果在调用validate()之前,这个锁没有写锁申请过,那就返回true,这也表示锁保护的共享数据并没有被修改,因此之前的读取操作是肯定能保证数据完整性和一致性的。
反之,如果锁在validate()之前有写锁申请成功过,那就表示,之前的数据读取和写操作冲突了,程序需要进行重试,或者升级为悲观锁。
和重入锁的比较
从上面的例子其实不难看到,就编程复杂度来说,StampedLock其实是要比重入锁复杂的多,代码也没有以前那么简洁了。
那么,我们为什么还要使用它呢?
最本质的原因,就是为了提升性能!一般来说,这种乐观锁的性能要比普通的重入锁快几倍,而且随着线程数量的不断增加,性能的差距会越来越大。
简而言之,在大量并发的场景中StampedLock的性能是碾压重入锁和读写锁的。
但毕竟,世界上没有十全十美的东西,StampedLock也并非全能,它的缺点如下:
编码比较麻烦,如果使用乐观读,那么冲突的场景要应用自己处理
它是不可重入的,如果一不小心在同一个线程中调用了两次,那么你的世界就清净了。。。。。
它不支持wait/notify机制
如果以上3点对你来说都不是问题,那么我相信StampedLock应该成为你的首选。
内部数据结构
为了帮助大家更好的理解StampedLock,这里再简单给大家介绍一下它的内部实现和数据结构。
在StampedLock中,有一个队列,里面存放着等待在锁上的线程。该队列是一个链表,链表中的元素是一个叫做WNode的对象:
当队列中有若干个线程等待时,整个队列可能看起来像这样的:
除了这个等待队列,StampedLock中另外一个特别重要的字段就是long state, 这是一个64位的整数,StampedLock对它的使用是非常巧妙的。
state 的初始值是:
- private static final int LG_READERS = 7;
- private static final long WBIT = 1L << LG_READERS;
- private static final long ORIGIN = WBIT << 1;
也就是 ...0001 0000 0000 (前面的0太多了,不写了,凑足64个吧~),为什么这里不用0做初始值呢?因为0有特殊的含义,为了避免冲突,所以选择了一个非零的数字。
如果有写锁占用,那么就让第7位设置为1 ...0001 1000 0000,也就是加上WBIT。
每次释放写锁,就加1,但不是state直接加,而是去掉最后一个字节,只使用前面的7个字节做统计。因此,释放写锁后,state就变成了:...0010 0000 0000, 再加一次锁,又变成:...0010 1000 0000,以此类推。
这里为什么要记录写锁释放的次数呢?
这是因为整个state 的状态判断都是基于CAS操作的。而普通的CAS操作可能会遇到ABA的问题,如果不记录次数,那么当写锁释放掉,申请到,再释放掉时,我们将无法判断数据是否被写过。而这里记录了释放的次数,因此出现"释放->申请->释放"的时候,CAS操作就可以检查到数据的变化,从而判断写操作已经有发生,作为一个乐观锁来说,就可以准确判断冲突已经产生,剩下的就是交给应用来解决冲突即可。因此,这里记录释放锁的次数,是为了精确地监控线程冲突。
而state剩下的那一个字节的其中7位,用来记录读锁的线程数量,由于只有7位,因此只能记录可怜的126个,看下面代码中的RFULL,就是读线程满载的数量。超过了怎么办呢,多余的部分就记录在readerOverflow字段中。
- private static final long WBIT = 1L << LG_READERS;
- private static final long RBITS = WBIT - 1L;
- private static final long RFULL = RBITS - 1L;
- private transient int readerOverflow;
总结一下,state变量的结构如下:
写锁的申请和释放
在了解了StampedLock的内部数据结构之后,让我们再来看一下有关写锁的申请和释放吧!首先是写锁的申请:
- public long writeLock() {
- long s, next;
- return ((((s = state) & ABITS) == 0L && //有没有读写锁被占用,如果没有,就设置上写锁标记
- U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
- //如果写锁占用成功范围next,如果失败就进入acquireWrite()进行锁的占用。
- next : acquireWrite(false, 0L));
- }
如果CAS设置state失败,表示写锁申请失败,这时,会调用acquireWrite()进行申请或者等待。acquireWrite()大体做了下面几件事情:
入队
- 如果头结点等于尾结点wtail == whead, 表示快轮到我了,所以进行自旋等待,抢到就结束了
- 如果wtail==null ,说明队列都没初始化,就初始化一下队列
- 如果队列中有其他等待结点,那么只能老老实实入队等待了
阻塞并等待
- 如果头结点等于前置结点(h = whead) == p), 那说明也快轮到我了,不断进行自旋等待争抢
- 否则唤醒头结点中的读线程
- 如果抢占不到锁,那么就park()当前线程
简单地说,acquireWrite()函数就是用来争抢锁的,它的返回值就是代表当前锁状态的邮戳,同时,为了提高锁的性能,acquireWrite()使用大量的自旋重试,因此,它的代码看起来有点晦涩难懂。
写锁的释放如下所示,unlockWrite()的传入参数是申请锁时得到的邮戳:
- public void unlockWrite(long stamp) {
- WNode h;
- //检查锁的状态是否正常
- if (state != stamp || (stamp & WBIT) == 0L)
- throw new IllegalMonitorStateException();
- // 设置state中标志位为0,同时也起到了增加释放锁次数的作用
- state = (stamp += WBIT) == 0L ? ORIGIN : stamp;
- // 头结点不为空,尝试唤醒后续的线程
- if ((h = whead) != null && h.status != 0)
- //唤醒(unpark)后续的一个线程
- release(h);
- }
读锁的申请和释放
获取读锁的代码如下:
- public long readLock() {
- long s = state, next;
- //如果队列中没有写锁,并且读线程个数没有超过126,直接获得锁,并且读线程数量加1
- return ((whead == wtail && (s & ABITS) < RFULL &&
- U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
- //如果争抢失败,进入acquireRead()争抢或者等待
- next : acquireRead(false, 0L));
- }
acquireRead()的实现相当复杂,大体上分为这么几步:
总之,就是自旋,自旋再自旋,通过不断的自旋来尽可能避免线程被真的挂起,只有当自旋充分失败后,才会真正让线程去等待。
下面是释放读锁的过程:
StampedLock悲观读占满CPU的问题
StampedLock固然是个好东西,但是由于它特别复杂,难免也会出现一些小问题。下面这个例子,就演示了StampedLock悲观锁疯狂占用CPU的问题:
- public class StampedLockTest {
- public static void main(String[] args) throws InterruptedException {
- final StampedLock lock = new StampedLock();
- Thread t1 = new Thread(() -> {
- // 获取写锁
- lock.writeLock();
- // 模拟程序阻塞等待其他资源
- LockSupport.park();
- });
- t1.start();
- // 保证t1获取写锁
- Thread.sleep(100);
- Thread t2 = new Thread(() -> {
- // 阻塞在悲观读锁
- lock.readLock();
- });
- t2.start();
- // 保证t2阻塞在读锁
- Thread.sleep(100);
- // 中断线程t2,会导致线程t2所在CPU飙升
- t2.interrupt();
- t2.join();
- }
- }
上述代码中,在中断t2后,t2的CPU占用率就会沾满100%。而这时候,t2正阻塞在readLock()函数上,换言之,在受到中断后,StampedLock的读锁有可能会占满CPU。这是什么原因呢?机制的小傻瓜一定想到了,这是因为StampedLock内太多的自旋引起的!没错,你的猜测是正确的。
具体原因如下:
如果没有中断,那么阻塞在readLock()上的线程在经过几次自旋后,会进入park()等待,一旦进入park()等待,就不会占用CPU了。但是park()这个函数有一个特点,就是一旦线程被中断,park()就会立即返回,返回还不算,它也不给你抛点异常啥的,那这就尴尬了。本来呢,你是想在锁准备好的时候,unpark()的线程的,但是现在锁没好,你直接中断了,park()也返回了,但是,毕竟锁没好,所以就又去自旋了。
转着转着,又转到了park()函数,但悲催的是,线程的中断标记一直打开着,park()就阻塞不住了,于是乎,下一个自旋又开始了,没完没了的自旋停不下来了,所以CPU就爆满了。
要解决这个问题,本质上需要在StampedLock内部,在park()返回时,需要判断中断标记为,并作出正确的处理,比如,退出,抛异常,或者把中断位给清理一下,都可以解决问题。
但很不幸,至少在JDK8里,还没有这样的处理。因此就出现了上面的,中断readLock()后,CPU爆满的问题。请大家一定要注意。
写在最后
今天,我们比较仔细地介绍了StampedLock的使用和主要实现思想,StampedLock是一种重入锁和读写锁的重要补充。
它提供了一种乐观锁的策略,是一种与众不同的锁实现。当然了,就编程难度而言,StampedLock会比重入锁和读写锁稍微繁琐一点,但带来的却是性能的成倍提升。
这里给大家提一些小意见,如果我们的应用线程数量可控,并且不多,竞争不太激烈,那么就可以直接使用简单的synchronized,重入锁,读写锁就好了;如果应用线程数量多,竞争激烈,并且对性能敏感,那么还是需要我们劳神费力,用一下比较复杂的StampedLock,来提高一下程序的吞吐量。
使用StampedLock还需要特别注意两点:第一StampedLock不是可重入的,千万不要单线程自己和自己搞死锁了,第二,StampedLock没有等待/通知机制,如果一定需要这个功能的话,也只能绕行啦!
我是敖丙,你知道的越多,不知道的越多,我们下期见。