shz.core.lock.StampedLockHolder Maven / Gradle / Ivy

package shz.core.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.StampedLock;
import java.util.function.Supplier;

/**
 * StampedLock是并发包里面JDK8版本新增的一个锁，该锁提供了三种模式的读写控制，
 * 
 * 当调用获取锁的系列函数时，会返回一个long型的变量，我们称之为戳记（stamp），这个戳记代表了锁的状态。
 * 

 * 其中try系列获取锁的函数，当获取锁失败后会返回为0的stamp值。
 * 

 * 当调用释放锁和转换锁的方法时需要传入获取锁时返回的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还支持这三种锁在一定条件下进行相互转换，期望把stamp标示的锁升级为写锁
 * 

 * tryConvertToWriteLock这个函数会在下面几种情况下返回一个有效的stamp（也就是晋升写锁成功）：
 * 

 * ● 当前锁已经是写锁模式了。
 * 

 * ● 当前锁处于读锁模式，并且没有其他线程是读锁模式
 * 
 * ● 当前处于乐观读模式，并且当前写锁可用。
 */
public class StampedLockHolder implements LockHolder {
    protected final StampedLock sl;

    public StampedLockHolder() {
        sl = new StampedLock();
    }

    @Override
    public final  R applyRead(Supplier supplier, long time, TimeUnit unit) {
        // 乐观读锁
        long stamp = sl.tryOptimisticRead();
        // 检查时间戳判断是否有写线程抢占
        if (sl.validate(stamp)) return supplier.get();

        // 如果被抢占则获取悲观读锁
        stamp = sl.readLock();
        try {
            return supplier.get();
        } finally {
            sl.unlockRead(stamp);
        }
    }

    @Override
    public final  R applyRead(Supplier supplier) {
        return LockHolder.super.applyRead(supplier);
    }

    @Override
    public final void acceptRead(Runnable runnable, long time, TimeUnit unit) {
        long stamp = sl.tryOptimisticRead();
        if (sl.validate(stamp)) {
            runnable.run();
            return;
        }

        stamp = sl.readLock();
        try {
            runnable.run();
        } finally {
            sl.unlockRead(stamp);
        }
    }

    @Override
    public final void acceptRead(Runnable runnable) {
        LockHolder.super.acceptRead(runnable);
    }

    @Override
    public final  R applyWrite(Supplier supplier, long time, TimeUnit unit) {
        // 写锁-排他锁
        long stamp = sl.writeLock();
        try {
            return supplier.get();
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    @Override
    public final  R applyWrite(Supplier supplier) {
        return LockHolder.super.applyWrite(supplier);
    }

    @Override
    public final void acceptWrite(Runnable runnable, long time, TimeUnit unit) {
        long stamp = sl.writeLock();
        try {
            runnable.run();
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    @Override
    public final void acceptWrite(Runnable runnable) {
        LockHolder.super.acceptWrite(runnable);
    }
}