面试居然问到了StampedLock,我却是啥都不知道...

点赞再看,养成习惯,微信搜索【三太子敖丙】关注这个好像有点东西的傻瓜

本文 GitHub https://github.com/JavaFamily 已收录,有一线大厂面试完整考点、资料、简历模板,以及我的程序人生。

前言

在多线程开发中,为了控制线程同步,使用的最多的莫过于synchronized 关键字和重入锁。在JDK8中,又引入了一款新式武器StampedLock。这是一个什么东西呢?英文单词Stamp,意思是邮戳。那在这里有用什么含义呢?傻瓜,请看下面的分解。

面对临界区资源管理的问题,大体上有2套思路:

第一就是使用悲观的策略,悲观者这样认为:在每一次访问临界区的共享变量,总是有人会和我冲突,因此,每次访问我必须先锁住整个对象,完成访问后再解锁。

而与之相反的乐天派却认为,虽然临界区的共享变量会冲突,但是冲突应该是小概率事件,大部分情况下,应该不会发生,所以,我可以先访问了再说,如果等我用完了数据还没人冲突,那么我的操作就是成功;如果我使用完成后,发现有人冲突,那么我要么再重试一次,要么切换为悲观的策略。

从这里不难看到,重入锁以及synchronized 是一种典型的悲观策略。聪明的你一定也猜到了,StampedLock就是提供了一种乐观锁的工具,因此,它是对重入锁的一个重要的补充。

StampedLock的基本使用

在StampedLock的文档中就提供了一个非常好的例子,让我们可以很快的理解StampedLock的使用。下面让我看一下这个例子,有关它的说明,都写在注释中了。

这里再说明一下validate()方法的含义,函数签名长这样:

public boolean validate(long stamp)

它的接受参数是上次锁操作返回的邮戳,如果在调用validate()之前,这个锁没有写锁申请过,那就返回true,这也表示锁保护的共享数据并没有被修改,因此之前的读取操作是肯定能保证数据完整性和一致性的。

反之,如果锁在validate()之前有写锁申请成功过,那就表示,之前的数据读取和写操作冲突了,程序需要进行重试,或者升级为悲观锁。

和重入锁的比较

从上面的例子其实不难看到,就编程复杂度来说,StampedLock其实是要比重入锁复杂的多,代码也没有以前那么简洁了。

那么,我们为什么还要使用它呢?

最本质的原因,就是为了提升性能!一般来说,这种乐观锁的性能要比普通的重入锁快几倍,而且随着线程数量的不断增加,性能的差距会越来越大。

简而言之,在大量并发的场景中StampedLock的性能是碾压重入锁和读写锁的。

但毕竟,世界上没有十全十美的东西,StampedLock也并非全能,它的缺点如下:

  1. 编码比较麻烦,如果使用乐观读,那么冲突的场景要应用自己处理
  2. 它是不可重入的,如果一不小心在同一个线程中调用了两次,那么你的世界就清净了。。。。。
  3. 它不支持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()大体做了下面几件事情:

  1. 入队
    1. 如果头结点等于尾结点wtail == whead, 表示快轮到我了,所以进行自旋等待,抢到就结束了
    2. 如果wtail==null ,说明队列都没初始化,就初始化一下队列
    3. 如果队列中有其他等待结点,那么只能老老实实入队等待了
  2. 阻塞并等待
    1. 如果头结点等于前置结点(h = whead) == p), 那说明也快轮到我了,不断进行自旋等待争抢
    2. 否则唤醒头结点中的读线程
    3. 如果抢占不到锁,那么就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没有等待/通知机制,如果一定需要这个功能的话,也只能绕行啦!

小傻瓜们对这个冷门类是否有深一步的理解了?理解了可以在评论区来一波:变得更强

我是敖丙,你知道的越多,不知道的越多,我们下期见。


敖丙把自己的面试文章整理成了一本电子书,共 1630页!

干货满满,字字精髓。目录如下,有我复习时总结的面试题以及简历模板,现在免费送给大家。

链接:https://pan.baidu.com/s/1ZQEKJBgtYle3v-1LimcSwg 密码:wjk6


文章持续更新,可以微信搜一搜「 三太子敖丙 」第一时间阅读,回复【资料】有我准备的一线大厂面试资料和简历模板,本文 GitHub https://github.com/JavaFamily 已经收录,有大厂面试完整考点,欢迎Star。

敖 丙 CSDN认证博客专家 CSDN签约作者 算法工程师 B站网红UP
微信搜一搜【敖丙】关注这个文绉绉的程序员,关注后回复【资料】有我准备的一线大厂面试资料和简历模板。
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页