深入了解Java中的StampedLock读写锁

在上一篇文章中,我们讨论了ReentrantReadWriteLock读写锁的一些问题,其中提到了由于写锁的悲观性可能导致”写饥饿”现象,从而降低了读写效率。今天,我们将介绍一种解决这一问题的工具:StampedLock。StampedLock是Java中一种性能更好的读写锁,被誉为Java锁王,它的引入为解决”写饥饿”问题提供了新的可能。

需要注意的是,虽然在Java的面试过程中很少被问及,但StampedLock的实现逻辑仍然值得我们深入学习。


StampedLock 是什么?

StampedLock是由Java8引入的一种性能更好的读写锁,由Doug Lea开发。与ReentrantReadWriteLock类似,StampedLock支持读锁和写锁,但同时还增加了乐观读锁的实现,这一点直接提升了它的性能。


StampedLock的原理

尽管StampedLock性能更好,但它不支持重入,也不支持条件变量Condition,并且并没有直接实现Lock或者ReadWriteLock接口,而是采用类似AQS(AbstractQueuedSynchronizer)的底层实现CLH(Craig, Landin, and Hagersten locks)。

在Java的官方文档中对它进行了如下描述:

官方还提供了一个示例:

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); // 释放写锁
        }
    }

    // 使用乐观读锁访问共享资源
    double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead(); // 获取乐观读锁
        double currentX = x, currentY = y;  // 拷贝共享资源到本地方法栈中
        if (!sl.validate(stamp)) { // //检查乐观读锁后是否有其他写锁发生,有则返回false
            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) {
        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); // 释放所有锁
        }
    }
}

StampedLock的底层提供了三种锁:


  1. 写锁:

    独占锁,一把锁只能被一个线程获得。当一个线程获取写锁后,其他请求读锁和写锁的线程必须等待。类似于ReentrantReadWriteLock的写锁,不过这里的写锁是不可重入的。

  2. 读锁(悲观读):

    共享锁,没有线程获取写锁的情况下,多个线程可以同时持有读锁。如果已经有线程持有写锁,则其他线程请求获取该读锁会被阻塞。类似于ReentrantReadWriteLock的读锁,不过这里的读锁是不可重入的。

  3. 乐观读:

    允许多个线程获取乐观读以及读锁。同时允许一个写线程获取写锁。


【源码示例】

// 写锁
public long writeLock() {
    long s, next;  // bypass acquireWrite in fully unlocked case only
    return ((((s = state) & ABITS) == 0L &&
             U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
            next : acquireWrite(false, 0L));
}
// 读锁
public long readLock() {
    long s = state, next;  // bypass acquireRead on common uncontended case
    return ((whead == wtail && (s & ABITS) < RFULL &&
             U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
            next : acquireRead(false, 0L));
}
// 乐观读
public long tryOptimisticRead() {
    long s;
    return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
}

StampedLock在获取锁时会返回一个long型的数据戳,该数据戳用于稍后的锁释放参数。如果返回的数据戳为0,则表示锁获取失败。当前线程持有了锁再次获取锁还会返回一个新的数据戳,这也是StampedLock不可重入的原因。此外,在官方给出的示例中,我们还可以看到StampedLock支持这3种锁的转换:

long tryConvertToWriteLock(long stamp){}
long tryConvertToReadLock(long stamp){}
long tryConvertToOptimisticRead(long stamp){}



内部常量说明

在源码中我们看到,无论哪种锁,在获取的时候都会返回一个long类型的时间戳,这其实就是StampedLock命名的由来。而这个时间戳的第8位用来标识写锁,前7位(LG_READERS)来表示读锁,每获取一个悲观读锁,就加1(RUNIT),每释放一个悲观读锁,就减1。悲观读锁最多只能装128个(7位限制),很容易溢出,所以用一个int类型的变量来存储溢出的悲观读锁。


StampedLock的使用

结合StampedLock的特性和官方示例,我们编写一个小demo来感受它的使用。需要注意的是,在获取乐观锁时,如果有写锁改变数据时,为保证数据一致性,要切换为普通的读锁模式。


【测试示例】

public class Test {

    private final StampedLock sl = new StampedLock();
    private int data = 0;

    public void write(int value) {
        long stamp = sl.writeLock();
        try {
            data = value;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    public int read() {
        long stamp = sl.tryOptimisticRead();
        int currentData = data;
        // 如果有写锁被占用,可能造成数据不一致,所以要切换到普通读锁模式
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                currentData = data;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return currentData;
    }

    public static void main(String[] args) {
        Test test = new Test();

        Thread writer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                test.write(i);
                System.out.println("当前线程" + Thread.currentThread().getName() + ":Write: " + i);
            }
        });

        Thread reader = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                int value = test.read();
                System.out.println("当前线程" + Thread.currentThread().getName() + ":Read: " + value);
            }
        });

        writer.start();
        reader.start();
    }
}


输出:

当前线程Thread-0:Write: 0
当前线程Thread-0:Write: 1
当前线程Thread-1:Read: 0
当前线程Thread-0:Write: 2
当前线程Thread-1:Read: 2
当前线程Thread-0:Write: 3
当前线程Thread-1:Read: 3
当前线程Thread-0:Write: 4
当前线程Thread-1:Read: 4
当前线程Thread-1:Read: 4

总结

相比于传统读写锁,StampedLock由于增加了乐观读锁,因此性能更好。StampedLock的乐观读允许一个写线程获取写锁,不会导致所有写线程阻塞,当读操作频繁而写操作较少时,写线程有机会获取写锁,减少了线程饥饿问题,提高了吞吐量。

不过,需要注意的是,StampedLock不支持重入,不支持条件变量Condition,对中断操作支持也不友好(使用不当容易导致CPU飙升)。如果需要使用ReentrantLock的一些高级性能,就不太建议使用StampedLock。


结尾彩蛋

如果本篇博客对您有一定的帮助,欢迎留言、点赞和收藏。原创不易,转载请联系Build哥!

如果您想与Build哥的关系更近一步,还可以关注“JavaBuild888”,在这里除了看到《Java成长计划》系列博文,还有提升工作效率的小笔记、读书心得、大厂面经、人生感悟等等,欢迎您的加入!

未经允许不得转载:大白鲨游戏网 » 深入了解Java中的StampedLock读写锁