java并发编程——我和StampedLock的二三事

最新推荐文章于 2024-09-03 12:03:35 发布

mkfka

最新推荐文章于 2024-09-03 12:03:35 发布

阅读量123

点赞数

分类专栏： java并发编程

本文链接：https://blog.csdn.net/mkfka/article/details/108690537

版权

java并发编程专栏收录该内容

9 篇文章 1 订阅

订阅专栏

StampedLock

一、StampedLock概述
- 1.1 为什么会有StampedLock？
- 1.2 StampedLock的特点
二、StampedLock的使用
三、StampedLock原理

一、StampedLock概述

1.1 为什么会有StampedLock？

StampedLock类，在JDK1.8时引入，是对读写锁ReentranReadWriteLock的增强，该类提供的一些功能，优化了读锁、写锁的访问，同时使读写锁之间可以互相转化，更细粒度的控制并发。那么，大家有没有思考过，已经有了ReentranReadWriteLock，为什么还要设计一个StampedLock呢？ReentranReadWriteLock使得多个线程同时持有读锁（只要写锁未被占用），而写锁是独占的。但是读写锁如果使用不当，很容易产生“锁饥饿”。比如在读线程非常多，写线程很少的情况下，很容易导致写线程出现“锁饥饿”的现象。

1.2 StampedLock的特点

StampedLock的主要特点有以下几点：
1、所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为0表示获取失败，其余都表示成功。
2、所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致，
3、StampedLock是不可重入的；如果一个线程已经持有写锁，再去获取写锁的话就会造成死锁。
4、StampedLock有三种访问模式
（1）Reading（读模式）:功能和ReentranReadWriteLock的读锁类似。
（2）Reading（写模式）:功能和ReentranReadWriteLock的写锁类似。
（3）Optimistic reading（乐观读模式）：这是一种优化的读模式
5、 StampedLock支持读锁和写锁的相互转换
6、无论写锁还是读锁，都不支持condition等待
在ReentrantReadWriteLock中，当读锁被使用时，如果有线程尝试获取写锁，该写线程会阻塞。但是，在Optimistic reading中，即使读线程获取到了读锁，写线程尝试获取写锁也不会阻塞，这相当于对读模式的优化，但是可能会导致数据不一致的问题。所以，当使用Optimistic reading获取到读锁时，必须对获取结果进行校验。

二、StampedLock的使用

class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();    //涉及对共享资源的修改，使用写锁-独占操作
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    /**
     * 使用乐观读锁访问共享资源
     * 注意：乐观读锁在保证数据一致性上需要拷贝一份要操作的变量到方法栈，并且在操作数据时候可能其他写线程已经修改了数据，
     * 而我们操作的是方法栈里面的数据，也就是一个快照，所以最多返回的不是最新的数据，但是一致性还是得到保障的。
     *
     * @return
     */
    double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead();    // 使用乐观读锁
        double currentX = x, currentY = y;      // 拷贝共享资源到本地方法栈中
        if (!sl.validate(stamp)) {              // 如果有写锁被占用，可能造成数据不一致，所以要切换到普通读锁模式
            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) { // 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);
        }
    }
}

上述示例最特殊的其实是distanceFromOrigin方法，这个方法中使用了“Optimistic reading”乐观读锁，使得读写可以并发执行，但是“Optimistic reading”的使用必须遵循以下模式。

long stamp = lock.tryOptimisticRead();  // 非阻塞获取版本信息
copyVaraibale2ThreadMemory();           // 拷贝变量到线程本地堆栈
if(!lock.validate(stamp)){              // 校验
    long stamp = lock.readLock();       // 获取读锁
    try {
        copyVaraibale2ThreadMemory();   // 拷贝变量到线程本地堆栈
     } finally {
       lock.unlock(stamp);              // 释放悲观锁
    }
}
useThreadMemoryVarables();              // 使用线程本地堆栈里面的数据进行操作

三、StampedLock原理

示例：
假设现有三个线程：ThreadA、ThreadB、ThreadC、ThreadD。操作如下：
//ThreadA调用writeLock, 获取写锁
//ThreadB调用readLock, 获取读锁
//ThreadC调用readLock, 获取读锁
//ThreadD调用writeLock, 获取写锁
//ThreadE调用readLock, 获取读锁

ThreadA调用writeLock获取写锁
操作完成后，等待队列的结构如下：
ThreadB调用readLock获取读锁
最终，等待队列的结构如下：
ThreadC调用readLock获取读锁

注意：读结点的cowait字段其实构成了一个栈，入栈的过程其实是个“头插法”插入单链表的过程。比如，再来个ThreadX读结点，则cowait链表结构为：ThreadB - > ThreadX -> ThreadC。最终唤醒读结点时，将从栈顶开始。
可以看到，此时ThreadC结点并没有把它的前驱的等待状态置为-1，因为ThreadC是链接到栈中的，当写锁释放的时候，会从栈底元素开始，唤醒栈中所有读结点。
ThreadD调用writeLock获取写锁
ThreadE调用readLock获取读锁
最终队列结构如下：
ThreadA调用unlockWrite释放写锁
ThreadB被唤醒后继续向下执行
ThreadB发现写锁未被占用，则成功获取到读锁，然后从栈顶（ThreadB的cowait指针指向的结点）开始唤醒栈中所有线程。
最后返回：
ThreadC被唤醒后继续向下执行

在这里插入图片描述

ThreadB和ThreadC释放读锁
ThreadB和ThreadC调用unlockRead方法释放读锁，CAS操作State将读锁数量减1
注意，当读锁的数量变为0时才会调用release方法，唤醒队首结点。
队首结点（ThreadD写结点被唤醒），最终等待队列的结构如下：
ThreadD被唤醒后继续向下执行
ThreadD调用unlockWrite释放写锁

最终，等待队列的结构如下：