读写锁&邮戳锁

Yumo

2023-03-11

Java

JUC, Java, 并发

面试题

你知道Java里面有哪些锁？
你说你用过读写锁，锁饥饿问题是什么？
有没有比读写锁更快的锁？
StampedLock知道吗？（邮戳锁/票据锁）
ReentrantReadWriteLock有锁降级机制，你知道吗

读写锁ReentrantReadWriteLock

定义：个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程

排他锁和共享锁

排它锁：又称独占锁，独享锁 synchronized，ReentrantLock都是排它锁

以ReentrantLock为例，会发现读操作互斥，只能一个线程一个线程读，性能差

// 资源类
public class MyResource {
    Map<String,String> map = new HashMap<>();
    Lock lock = new ReentrantLock(); // 独占锁 类似synchronized
    ReadWriteLock rwLock = new ReentrantReadWriteLock();
    public void write(String key,String value){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在写入");
            map.put(key,value);
            try{ TimeUnit.MILLISECONDS.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t完成写入");
        }finally {
            lock.unlock();
        }
    }
    public void read(String key){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在读取");
            String res = map.get(key);
            try{ TimeUnit.MILLISECONDS.sleep(200); }catch(InterruptedException e){ e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t完成读取"+res);
        }finally {
            lock.unlock();
        }
    }
}

public class ReentrantReadWriteLockDemo {
    public static void main(String[] args) {
        MyResource myResource = new MyResource();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.write(finalI +"", finalI +"");
            },String.valueOf(i)).start();
        }
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.read(finalI +"");
            },String.valueOf(i)).start();
        }
    }
}

可以看到输出结果中写写/写读/读读都互斥

共享锁：又称为读锁，获得共享锁后，可以查看，但无法删除和修改数据，其他线程此时也可以获取到共享锁，也可以查看但是无法修改和删除数据

共享锁和排它锁典型是ReentranReadWriteLock
写锁是排它锁
读锁是共享锁

读写锁优势

大实际生活中多实际场景是“读/读”线程间并不存在互斥关系, 只有“读/写”线程或”写/写”线程间的操作需要互斥的。因此引ReentrantReadWriteLock。

ReentrantReadWriteLock它只允许读读共存,而读写和写写依然是互斥的,

一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁,但不能同时存在写锁和读锁(切菜还是拍蒜选一个)。也即

一个资源可以被多个读操作访问
一个写操作访问,
读写仍然互斥。

只有在读多写少情景之下,读写锁才具有较高的性能体现。

读读不互斥

public class MyResource {
    Map<String,String> map = new HashMap<>();
    Lock lock = new ReentrantLock(); // 独占锁 类似synchronized
    ReadWriteLock rwLock = new ReentrantReadWriteLock();
    public void write(String key,String value){
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在写入");
            map.put(key,value);
            try{ TimeUnit.MILLISECONDS.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t完成写入");
        }finally {
            rwLock.writeLock().unlock();
        }
    }
    public void read(String key){
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在读取");
            String res = map.get(key);
            try{ TimeUnit.MILLISECONDS.sleep(200); }catch(InterruptedException e){ e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t完成读取"+res);
        }finally {
            rwLock.readLock().unlock();
        }
    }
}

读写锁的锁降级

ReentrantReadWriteLock锁降级 : 将写入锁降级为读锁(类似Linux文件读写权限理解,就像写权限要高于读权限一样),

锁的严苛程度变强叫做升级，反之叫做降级。

写锁的降级,降级成为了读锁

即如果同一个线程持有了写锁,在没有释放写锁的情况下,它还可以继续获得读锁。这就是写锁的降级,降级成为了读锁。
降级的规则是：
- 按照先获取写锁,然后获取读锁,再释放写锁的次序。
- 如果释放了写锁,那么就完全转换为读锁。

public class LockDownGradingDemo {
    static String cacheValid = null;
    public static void main(String[] args) {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
        // 锁降级 写锁 -> 读锁
        new Thread(() -> {
            writeLock.lock();
            System.out.println(Thread.currentThread().getName()+"\t"+LocalTime.now()+"\t正在写入");
            try{ TimeUnit.SECONDS.sleep(2); }catch(InterruptedException e){ e.printStackTrace(); }
            cacheValid="A";
            System.out.println(Thread.currentThread().getName()+"\t"+LocalTime.now()+"\t完成写入");
            readLock.lock();
            System.out.println(Thread.currentThread().getName()+"\t"+LocalTime.now()+"\t正在读取");
            try{ TimeUnit.SECONDS.sleep(1); }catch(InterruptedException e){ e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+LocalTime.now()+"\t完成读取\t"+cacheValid);
            writeLock.unlock();
            readLock.unlock();
        },"A").start();


        new Thread(() -> {
            readLock.lock();
            System.out.println(Thread.currentThread().getName()+"\t"+LocalTime.now()+"\t正在读取");
            try{ TimeUnit.SECONDS.sleep(1); }catch(InterruptedException e){ e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+LocalTime.now()+"\t完成读取\t"+cacheValid);
            readLock.unlock();
        },"B").start();
    }
}

设计思想

代码中声明了一个volatile类型的cacheValid变量,保证其可见性。
首先获取读锁,如果cache不可用, 则释放读锁。获取写锁，写点东西，在更改数据之前, 再检查一次cacheValid的值（双检），然后修改数据,将 cacheValid置为true,
然后在释放写锁前立刻抢夺获取读锁；此时, cache中数据可用, 处理cache中数据,最后释放读锁。

这个过程就是一个完整的锁降级的过程,目的是保证数据可见性。

如果违背锁降级的步骤

如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁

那么假设此时另一个线程D获取了写锁并修改了数据，则C线程无法感知到数据已被修改，数据出现错误。

如果遵循锁降级的步骤

在ReentrantReadWriteLock中，当读锁被使用时，如果有线程尝试获取写锁，该写线程会被阻塞。

所以，需要释放所有读锁，才可获取写锁，

写后立刻读：写后读的数据保证是这次更新的数据，该机制是专门为缓存设计的
写后重入读：同一个线程自己持有写锁时再去拿读锁,其本质相当于重入。防止写完数据释放写锁之后被别的写线程抢占，这样可以立马使用自己修改过的最新数据

写锁饥饿问题

写锁和读锁是互斥的（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。

因此，分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题:

读锁结束，写锁有望
写锁独占，读写全堵

如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁

即ReentrantReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，

也就是写入必须等待，这是一种悲观的读锁

邮戳锁StampedLock

缓解写锁饥饿问题：使用“公平”策略可以一定程度上缓解这个问题

1	new Reentrant ReadWriteLock(true)

但是”公平”策略是以牺牲系统吞吐量为代价的，有没有比读写锁更快的锁？

StampedLock是JDK1.8中新增的一个读写锁, 也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化。

StampedLock是由锁饥饿问题引出的

锁饥饿问题 : ReentrantReadWriteLock实现了读写分离,但是一旦读操作比较多的时候,想要获取写锁就变得比较困难了,

假如当前1000个线程,999个读,1个写,有可能999个读取线程长时间抢到了锁,那1个写线程就悲剧了因为当前有可能会一直存在读锁,而无法获得写锁,根本没机会写

StampedLock横空出世

ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。

但是StampedLock采取乐观获取读锁，获取读锁之后其他线程再尝试获取写锁时不会被阻塞，这其实是对读锁的优化。使用乐观读锁模式可以提高吞吐量
所以，在获取乐观读锁后，还需要对结果进行校验。

邮戳锁原理

邮戳锁的基本特点：

所有获取锁的方法,都返回一个邮戳(Stamp),Stamp为零表示获取失败,其余都表示成功;
所有释放锁的方法,都需要一个邮戳(Stamp),这个Stamp必须是和成功获取锁时得到的Stamp一致;
StampedLock是不可重入的，没有Re开头。危险(如果一个线程已经持有了写锁,再去获取写锁的话就会造成死锁)
StampedLock 的悲观读锁和写锁都不支持条件变量(Condition),这个也需要注意。
使用 StampedLock一定不要调用中断操作,即不要调用interrupt()方法

StampedLock有三种访问模式：

Reading(读模式悲观) : 功能和ReentrantReadWriteLock的读锁类似
Writing(写模式悲观) : 功能和ReentrantReadWriteLock的写锁类似
Optimistic reading(乐观读模式) : 无锁机制,类似于数据库中的乐观锁, 支持读写并发,很乐观认为读取时没人修改,假如被修改再实现升级为悲观读模式
- 乐观的阅读。仅当锁定当前未处于写入模式时,方法**tryOptimisticRead()**才返回非零戳记。如果自获得给定标记以来没有在写入模式下获取锁定,则方法validate(long)返回 true。这种模式可以被认为是读锁的极弱版本,可以随时被作者破坏。对短的只读代码段使用乐观模式通常可以减少争用并提高吞吐量。但是,它的使用本质上是脆弱的。
- 乐观读取部分应该只读取字段并将它们保存在局部变量中,以便以后在验证后使用。在乐观模式下读取的字段可能非常不一致,因此仅在您熟悉数据表示以检查一致性和/或重复调用方法validate() 例如,在首次读取对象或数组引用,然后访问其中一个字段,元素或方法时,通常需要执行此类步骤。

邮戳锁传统版读写锁功能演示

public class StampLockDemo {
    static int number = 0;
    static StampedLock stampedLock = new StampedLock();
    public void write(){
        long stamp = stampedLock.writeLock();
        System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t写线程准备修改");
        try {
            number++;
        }finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t写线程结束修改");
    }
    // 悲观读
    public void read(){
        long stamp = stampedLock.readLock();
        System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t读线程准备读取");
        for (int i = 0; i < 4; i++) {
            try{TimeUnit.SECONDS.sleep(1);}catch(InterruptedException e){e.printStackTrace();}
            System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t正在读取中");
        }
        try {
            int result = number;
            System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t获得成员变量值 "+result);
            System.out.println("写线程没有修改成功，读锁时写锁无法介入，传统的读写互斥");
        }finally {
            stampedLock.unlockRead(stamp);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        StampLockDemo resource = new StampLockDemo();
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(() -> {
            resource.read();
            countDownLatch.countDown();
        },"readThread").start();
        try{ TimeUnit.SECONDS.sleep(1); }catch(InterruptedException e){ e.printStackTrace(); }
        new Thread(() -> {
            System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t------come in");
            resource.write();
            countDownLatch.countDown();
        },"writeThread").start();
        countDownLatch.await();
        System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t获得成员变量值 "+number);
    }
}

邮戳锁增强版功能演示|允许写线程介入

获取stamp ：long stamp = stampedLock.tryOptimisticRead();
校验：validate public boolean validate(long stamp)
- 如果自获得给定标记以来没有在写入模式下获取锁定,则方法validate(long)返回 true。
- 如果标记代表当前持有的锁,则始终返回true。
- 如果标记为零,则始终返回false

若写线程完成修改，则此后乐观读锁升级为悲观锁

读线程代码块后面短暂的暂停2秒钟线程，使得写线程可介入

若optimisticRead()发现写线程介入了，则升级乐观读锁tryOptimisticRead为悲观读锁readLock

// 乐观读，读锁过程中可以获取写锁
public void optimisticRead(){
    long stamp = stampedLock.tryOptimisticRead();
    System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\tvalidate值 "+stampedLock.validate(stamp));
    int result = number;
    for (int i = 0; i < 4; i++) {
        try{TimeUnit.SECONDS.sleep(1);}catch(InterruptedException e){e.printStackTrace();}
        System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t正在读取中 validate值 "+stampedLock.validate(stamp));
    }
    if (!stampedLock.validate(stamp)){
        System.out.println("被修改过-----有写操作");
        stamp = stampedLock.readLock();
        try {
            System.out.println("乐观锁升级为悲观锁");
            result=number;
            System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t重新悲观读后result "+result);
        }finally {
            stampedLock.unlockRead(stamp);
        }
    }
    System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\tfinally result "+result);

}
public static void main(String[] args) throws InterruptedException {
    StampLockDemo resource = new StampLockDemo();
    CountDownLatch countDownLatch = new CountDownLatch(2);
    new Thread(() -> {
        resource.optimisticRead();
        countDownLatch.countDown();
    },"readThread").start();
    try{ TimeUnit.SECONDS.sleep(2); }catch(InterruptedException e){ e.printStackTrace(); }
    new Thread(() -> {
        System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t------come in");
        resource.write();
        countDownLatch.countDown();
    },"writeThread").start();

    countDownLatch.await();
    System.out.println(LocalTime.now()+"\t"+Thread.currentThread().getName()+"\t获得成员变量值 "+number);
}

若写线程没来得及完成修改，则乐观读锁无需升级

读线程代码块后面暂停6秒钟线程，使得写线程不可介入

StampedLock缺点

不可重入
悲观读锁和写锁不支持条件变量（Condition）
使用StampedLock一定不要调用中断操作，即不要调用interrupt()方法

大部分用的还是排他锁和读写锁