java并发编程——JDK8中新增的StampedLock锁探索

贵沫末

已于 2024-08-13 10:57:51 修改

阅读量16

点赞数

分类专栏： java 文章标签： java 开发语言

于 2021-03-17 10:53:37 首次发布

本文链接：https://blog.csdn.net/weixin_42789698/article/details/114907596

版权

java 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

文章目录

JDK8中新增的StampedLock锁探索

JDK8中新增的StampedLock锁探索

一、概述

StampedLock是并发包里面JDK8版本新增的一个锁，该锁提供了三种模式的读写控制，当调用获取锁的系列函数时，会返回一个long型的变量，我们称之为戳记（stamp），这个戳记代表了锁的状态。其中try系列获取锁的函数，当获取锁失败后会返回0的stamp值。当调用释放锁和装换锁的方法时需要传入获取锁时返回的值。StampedLock提供的三种读写模式的锁分别如下。

写锁writeLock：是一个排它锁或者独占锁，某时只有一个线程可以获取该锁，当一个线程获取该锁之后，其他请求读锁和写锁的线程必须等待，这类似ReentrantReadWriteLock的写锁（不同的是这里的写锁是不可重入锁）；当目前没有线程持有读锁或者写锁时才可以获取到该锁。请求该锁成功之后会放回一个stamp变量用来表示该锁的版本，当释放锁时需要调用unlockWrite方法并传递获取锁时的stamp参数。并且它提供了非阻塞的tryWriteLock方法。

悲观读锁readLock：是一个共享锁，在没有线程获取独占写锁的情况下，多个线程可以同时获取该锁。如果已经有线程持有写锁，则其他线程请求获取该读锁会被阻塞，这类似于ReentrantReadWriteLock的读锁（不同的是这里的读锁是不可重入锁）。这里说的悲观是指在具体操作数据前其会悲观地认为其他线程可能要对自己操作的数据进行修改，所以需要先对数据加锁，这是在读少写多的情况下的一种考虑。请求该锁成功后会放回一个stamp变量用来表示该锁的版本，当释放该锁时需要调用unlockRead方法并传入stamp参数。并且它提供了非阻塞的tryReadLock方法。

乐观读锁tryOptimisticRead：它是相对于悲观锁来说的，在操作数据前并没有通过CAS设置锁的状态，仅仅通过位运算测试。如果当前没有线程持有锁，则简单地返回一个非0的stamp版本信息。获取该stamp后在具体操作数据前还需要调用validate方法验证该stamp是否已经不可用，也就是看当调用tryOptimisticRead返回stamp后到当前时间期间是否有其他线程持有写锁，如果是则validate会返回0，否则就可以使用该stamp版本的锁对数据进行操作。由于tryOptimisticRead并没有使用CAS设置锁状态，所以不需要显式地释放该锁。该锁的一个特点是使用读多写少的场景，因为获取读锁只是使用位操作进行校验，不涉及CAS操作，所以效率会高很多，但是同时由于没有使用真正的锁，在保证数据一致性上需要复制一份要操作的变量到方法栈，并且在操作数据时可能其他写线程已经修改了数据，而我们操作的时方法栈里面的数据，也就是一个快照，所以最多返回的不是最新的数据，但是一致性还是得到保障的。

StampedLock还支持三种锁在一定条件下进行相互转换。例如long tryConvertToWriteLock(long stamp)期望把stamp标示的锁升级为写锁，这个函数会在下面几种情况下返回一个有效的stamp（也就是晋升写锁成功）：

当前锁已经是写锁模式了。
当前锁处于读锁模式，并且没有其他线程是读锁模式
当前处于乐观读模式，并且当前写锁可用。

另外，StampedLock的读写锁都是不可重入锁，所以在获取锁后释放锁前不应该在调用会获取锁的操作，以避免造成调用线程被阻塞。当多个线程同时尝试获取读锁和写锁时，谁先获取锁没有一定规则，完全都是尽力而为，是随机的。并且该锁不是直接实现Lock或ReadWriteLock接口，而是其在内部自己维护了一个双向阻塞队列。

二、演示案例

package com.gyk.lock;

import java.util.concurrent.locks.StampedLock;

public class TestStampLock {
    private static StampedLock sLock = new StampedLock();
    public static void main(String[] args) {
        Point p = new Point();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                p.moveIfAtOrigin(20, 20);
                p.move(1, 1);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 10; i ++) {
                System.out.println(p.distanceFromOrigin());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();


    }
}

class Point {
    private double x, y;

    private final StampedLock sLock = new StampedLock();

    /**
     * 移动这个点，使用排它锁，写锁
     * @param deltaX
     * @param deltaY
     */
    void move(double deltaX, double deltaY) {
        // 获取写锁
        long writeLockStamp = sLock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            // 释放写锁
            sLock.unlockWrite(writeLockStamp);
        }
    }

    /**
     * 乐观读锁
     * @return
     */
    double distanceFromOrigin() {
        long optimisticReadStamp = sLock.tryOptimisticRead();
        // 将变量读取到本地方法栈
        double currentX = x, currentY = y;
        // 判断当前stamp是否可用
        if (!sLock.validate(optimisticReadStamp)) {
            // 如果不可用就获取一个共享读锁
            long readLockStamp = sLock.readLock();
            // 再次将读到的数据保存到本地方法栈
            try {
                currentX = x;
                currentY = y;
            } finally {
                sLock.unlockRead(readLockStamp);
            }
        }
        // 返回计算结果
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    /**
     * 使用悲观读锁+转换写锁
     * @param newX
     * @param newY
     */
    void moveIfAtOrigin(double newX, double newY) {
        // 我们这里就获取悲观读锁
        long lockStamp = sLock.readLock();
        try {
            // 如果当前的值等于原点，就移动newX和newY，需要获取写锁
            while (x == 0.0 && y == 0.0) {
                // 尝试将读锁转换为写锁
                long ws = sLock.tryConvertToWriteLock(lockStamp);
                // 如果converToWriteLockStamp == 0说明转换失败
                if (ws == 0L) {
                    // 转换失败的话，我们需要重新获取写锁，先释放读锁，在获取写锁
                    sLock.unlockRead(lockStamp);
                    lockStamp = sLock.writeLock();
                }else {
                    lockStamp = ws;
                    x += newX;
                    y += newY;
                    break;
                }
            }
        } finally {
            sLock.unlock(lockStamp);
        }
    }
}