ReentrantLock、ReentrantReadWriteLock、StampedLock

1. ReentrantReadWriteLock

本章路线总纲
无锁→独占锁→读写锁→邮戳锁

关于锁的大厂面试题
你知道Java里面有哪些锁?
你说你用过读写锁,锁饥饿问题是什么?有没有比读写锁更快的锁?
StampedLock知道吗?(邮戳锁/票据锁)
ReentrantReadWriteLock有锁降级机制,你知道吗?

1.1 读写锁ReentrantReadWriteLock

读写锁:一个资源能够被多个读线程访问,或者被一个写线程访问但是不能同时存在读写线程。

它只允许读读共存,而读写和写写依然是互斥的,大多实际场景是“读/读”线程间并不存在互斥关系,只有"读/写"线程或"写/写"线程间的操作需要互斥的。因此引入ReentrantReadWriteLock
一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁,但不能同时存在写锁和读锁(切菜还是拍蒜选一个)。也即一个资源可以被多个读操作访问―或一个写操作访问,但两者不能同时进行。只有在读多写少情景下,读写锁才具有较高的性能体现。
在这里插入图片描述

1.2 锁降级

在这里插入图片描述
写锁的降级,降级成为了读锁
1)如果同一个线程持有了写锁,在没有释放写锁的情况下,它还可以继续获得读锁。这就是写锁的降级,降级成为了读锁。
2)规则惯例,先获取写锁,然后获取读锁,再释放写锁的次序。
3)如果释放了写锁,那么就完全转换为读锁。
在这里插入图片描述锁降级是为了让当前线程感知到数据的变化,目的是保证数据可见性

如果有线程在读,那么写线程是无法获取写锁的,是悲观锁的策略

在ReentrantReadWriteLock中,当读锁被使用时,如果有线程尝试获取写锁,该写线程会被阻塞。所以,需要释放所有读锁,才可获取写锁。

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

ReentrantReadWriteLock读的过程中不允许写,只有等待线程都释放了读锁,当前线程才能获取写锁,也就是写入必须等待,这是一种悲观的读锁,人家还在读着那,你先别去写,省的数据乱。

分析StampedLock(后面详细讲解),会发现它改进之处在于:
读的过程中也允许获取写锁介入(相当牛B,读和写两个操作也让你“共享”(注意引号)),这样会导致我们读的数据就可能不一致所以,需要额外的方法来判断读的过程中是否有写入,这是一种乐观的读锁。
显然乐观锁的并发效率更高,但一旦有小概率的写入导致读取的数据不一致,需要能检测出来,再读一遍就行。

1.3 为什么要锁降级?

在这里插入图片描述锁降级确实不太贴切,明明是锁切换,在写锁释放前由写锁切换成了读锁。问题的关键其实是为什么要在锁切换前就加上读锁呢?防止释放写锁的瞬间被其他线程拿到写锁然后修改了数据,然后本线程在拿到读锁后读取数据就发生了错乱。但是,我把锁的范围加大一点不就行了吗?在写锁的范围里面完成读锁里面要干的事。缺点呢就是延长了写锁的占用时长,导致性能下降。对于中小公司而言没必要,随便在哪都能把这点性能捡回来了!
在这里插入图片描述

2.4 锁饥饿问题

ReentrantReadWriteLock实现了读写分离,但是一旦读操作比较多的时候,想要获取写锁就变得比较困难了,假如当前1000个线程,999个读,1个写,有可能999个读取线程长时间抢到了锁,那1个写线程就悲剧了因为当前有可能会一直存在读锁,而无法获得写锁,根本没机会写。

如何缓解锁饥饿问题?
使用"公平"策略可以一定程度上缓解这个问题,但是"公平"策略是以牺牲系统吞吐量为代价的

StampedLock类的乐观读锁闪亮登场

2. 邮戳锁StampedLock

2.1 StampedLock横空出世

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

stamp(戳记,long类型)
代表了锁的状态。当stamp返回零时,表示线程获取锁失败。并且,当释放锁或者转换锁的时候,需要传入最初获取的stamp值。

ReentrantReadWriteLock的读锁被占用的时候,其他线程尝试获取写锁的时候会被阻塞。但是,StampedLock采取乐观获取锁后,其他线程尝试获取写锁时不会被阻塞,这其实是对读锁的优化,所以,在获取乐观读锁后,还需要对结果进行校验。

ReentrantReadWriteLock
允许多个线程向时读,但是只允许一个线程写,在线程获取到写锁的时候,其他写操作和读操作都会处于阻塞状态,
读锁和写锁也是互斥的,所以在读的时候是不允许写的,读写锁比传统的synchronized速度要快很多,原因就是在于ReentrantReadWriteLock支持读并发,读读可以共享。

对短的只读代码段,使用乐观模式通常可以减少争用并提高吞吐量

2.2 ReentrantLock、ReentrantReadWriteLock、StampedLock性能比较
public class ReentrantReadWriteLockTest {
    static Lock lock = new ReentrantLock();
    static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    static StampedLock stampedLock = new StampedLock();
    static int read = 1000;
    static int write = 3;
    static long mills = 10;

    public static void main(String[] args) {
        testReentrantLock();
        testReentrantReadWriteLock();
//        System.out.println("=========================");
        testStampedLock();
    }

    public static void testStampedLock() {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        ExecutorService executorServiceWrite = Executors.newFixedThreadPool(3);
        CountDownLatch latch = new CountDownLatch(read + write);
        long l = System.currentTimeMillis();
        for (int i = 0; i < read; i++) {
            executorService.execute(() -> {
//                tryOptimisticRead();
                readStampedLock();
                latch.countDown();
            });
        }
        for (int i = 0; i < write; i++) {
            executorServiceWrite.execute(() -> {
                writeStampedLock();
                latch.countDown();
//                System.out.println("时间间隔:"+(System.currentTimeMillis()-l));
            });
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        executorServiceWrite.shutdown();
        System.out.println("testStampedLock执行耗时:" + (System.currentTimeMillis() - l));
    }

    public static void testReentrantLock() {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        ExecutorService executorServiceWrite = Executors.newFixedThreadPool(3);
        CountDownLatch latch = new CountDownLatch(read + write);
        long l = System.currentTimeMillis();
        for (int i = 0; i < read; i++) {
            executorService.execute(() -> {
                read();
                latch.countDown();
            });
        }
        for (int i = 0; i < write; i++) {
            executorServiceWrite.execute(() -> {
                write();
                latch.countDown();
            });
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        executorServiceWrite.shutdown();
        System.out.println("testReentrantLock执行耗时:" + (System.currentTimeMillis() - l));
    }

    public static void testReentrantReadWriteLock() {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        ExecutorService executorServiceWrite = Executors.newFixedThreadPool(3);
        CountDownLatch latch = new CountDownLatch(read + write);
        long l = System.currentTimeMillis();
        for (int i = 0; i < read; i++) {
            executorService.execute(() -> {
                readLock();
                latch.countDown();
            });
        }
        for (int i = 0; i < write; i++) {
            executorServiceWrite.execute(() -> {
                writeLock();
                latch.countDown();
//                System.out.println("时间间隔:"+(System.currentTimeMillis()-l));
            });
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        executorServiceWrite.shutdown();
        System.out.println("testReentrantReadWriteLock执行耗时:" + (System.currentTimeMillis() - l));
    }

    public static void tryOptimisticRead() {
        long stamp = stampedLock.tryOptimisticRead();
        try {
            Thread.sleep(mills);
            if (!stampedLock.validate(stamp)) {
                long readLock = stampedLock.readLock();
                try {
                } finally {
                    stampedLock.unlock(readLock);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void readStampedLock() {
        long stamp = stampedLock.readLock();
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            stampedLock.unlock(stamp);
        }
    }

    public static void writeStampedLock() {
        long stamp = stampedLock.writeLock();
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            stampedLock.unlock(stamp);
        }
    }

    public static void readLock() {
        readWriteLock.readLock().lock();
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public static void writeLock() {
        readWriteLock.writeLock().lock();
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public static void read() {
        lock.lock();
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void write() {
        lock.lock();
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

执行结果

testReentrantLock执行耗时:15868
testReentrantReadWriteLock执行耗时:218
testStampedLock执行耗时:221

根据执行结果可以明显看出在读多写少的情况下,ReentrantLock的性能是比较差的,而ReentrantReadWriteLock和StampedLock性能差不多相同,而StampedLock主要是为了解决ReentrantReadWriteLock可能出现的锁饥饿问题。

2.2 StampedLock总结

StampedLock的特点
所有获取锁的方法,都返回一个邮戳( Stamp) , Stamp为零表示获取失败,其余都表示成功;
所有释放锁的方法,都需要一个邮戳(Stamp),这个Stamp必须是和成功获取锁时得到的Stamp一致;
StampedLock是不可重入的,危险(如果一个线程已经持有了写锁,再去获取写锁的话就会造成死锁)

StampedLock有三种访问模式
Reading (读模式悲观):功能和ReentrantReadWriteLock的读锁类似
Writing(写模式):功能和ReentrantRedWriteLock的写锁类似
Optimistic reading(乐观读模式):无锁机制,类似于数据库中的乐观锁,支持读写并发,很乐观认对为读取时没人修改,假如被修改再实现升级为悲观读模式

主要API
tryOptimisticRead():加乐观读锁
validate(long stamp):校验乐观读锁执行过程中有无写锁搅局

StampedLock的缺点
StampedLock 不支持重入,没有Re开头
StampedLock的悲观读锁和写锁都不支持条件变量(Condition),这个也需要注意。
使用StampedLock一定不要调用中断操作,即不要调用interrupt()方法

有关锁的知识都学习完了,其实挺鸡肋的,工作直接用分布式锁,几乎不会用到JVM层级的锁,但是面试要问,不得不学!

注:本文是学习B站周阳老师《尚硅谷2022版JUC并发编程》课程所做学习笔记。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值