JUC并发编程与源码分析笔记14-ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

王劭阳

已于 2023-06-17 17:51:21 修改

阅读量410

点赞数

分类专栏： JUC并发编程与源码分析文章标签： JUC

于 2023-05-25 23:36:26 首次发布

本文链接：https://blog.csdn.net/qq_36059561/article/details/130569580

版权

JUC并发编程与源码分析专栏收录该内容

15 篇文章 4 订阅

订阅专栏

本章线路总纲

无锁→独占锁→读写锁→邮戳锁
无锁：读和写同时进行，会产生大量的错误数据。
独占锁（synchronized，Lock接口，ReentrantLock）：此时就将读、写线程进行了有序排列，每次只处理一个请求，不会产生数据错乱，保证了数据一致性
读写锁（ReentrantReadWriteLock）：读写互斥，读读共享，适用于读多写少的情况，不过会有写锁饥饿问题和锁降级问题
邮戳锁（StampedLock）

关于锁的大厂面试题

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

简单聊聊ReentrantReadWriteLock

是什么

一个资源可以被多个读线程访问，或者被一个写线程访问，不能同时存在读写线程。

特点

它只允许读读共存，而读写和写写依然是互斥的，大多数场景是读读线程，不存在互斥关系，只有读写线程或者写写线程操作需要互斥，因此引入了ReentrantReadWriteLock。
一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但是不能同时存在写锁和读锁，即一个资源可以被多个读操作访问或一个写操作访问，但两者不能同时进行。
只有在读多写少的情况下，读写锁才具有较高的性能体现。

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyResource myResource = new MyResource();
        for (int i = 0; i < 10; i++) {// 10个线程同时写
            int finalI = i;
            new Thread(() -> {
                myResource.write(String.valueOf(finalI), String.valueOf(finalI));
            }, String.valueOf(i)).start();
        }

        for (int i = 0; i < 10; i++) {// 10个线程同时读
            int finalI = i;
            new Thread(() -> {
                myResource.read(String.valueOf(finalI));
            }, String.valueOf(i)).start();
        }
        Thread.sleep(1000);
        for (int i = 0; i < 3; i++) {// 3个线程同时写，此时读锁还没有释放，会出现写饥饿的现象
            int finalI = i;
            new Thread(() -> {
                myResource.write(String.valueOf(finalI), String.valueOf(finalI));
            }, "新的写线程" + i).start();
        }
    }
}

/**
 * 资源类，模拟一个简单的缓存
 */
class MyResource {
    Map<String, String> map = new HashMap();
    Lock lock = new ReentrantLock();// 等价于synchronized
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();// 读写互斥，读读共享

    public void write(String key, String value) {
//        lock.lock();
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "开始写入");
            map.put(key, value);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "结束写入");
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void read(String key) {
//        lock.lock();
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "开始读取");
            String value = map.get(key);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "结束读取");
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

ReentrantReadWriteLock锁降级：将写入锁降级为读锁（类似Linux文件读写权限理解，就像写权限要高于读权限一样），锁的严苛程度变强叫升级，反之叫降级。
写锁的降级，降级成了读锁。

如果同一个线程持有了写锁，在没有释放写锁的情况下，还可以继续获得读锁，这就是写锁的降级，降级成了读锁
规则惯例，先获取写锁，然后获取读锁，再释放写锁的次序，这个次序不能变，此时写锁降级为读锁
如果释放了写锁，就完全转换为读锁

锁降级就是为了让当前线程感知到数据的变化，目的是保证数据的可见性。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        {// 正常A B两个线程
            writeLock.lock();
            System.out.println("write");
            writeLock.unlock();

            readLock.lock();
            System.out.println("read");
            readLock.unlock();
        }
        {// 锁降级（写后读），这样的好处是，可以读取到自己线程修改后的数据，如果先释放写锁，那么写锁可能被其他线程抢到，读线程读取的可能是其他线程修改后的数据了
            writeLock.lock();
            System.out.println("write");
            readLock.lock();
            System.out.println("read");
            writeLock.unlock();
            readLock.unlock();
        }
        {// 锁升级，会卡住
            readLock.lock();
            System.out.println("read");
            writeLock.lock();
            System.out.println("write");
            writeLock.unlock();
            readLock.unlock();
        }
    }
}

写锁和读锁是互斥的（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。
因此，分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题：读锁结束，写锁有望；写锁独占，读写全堵。
如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁。即ReentrantReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁，省的数据乱。
后序会降到StampedLock，在读的过程中，也可以获取写锁，这样会导致读的数据不一致。
所以，需要额外的方法来判断读的过程中是否有写入，这是一种乐观的读锁，显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。
Oracle公司ReentrantReadWriteLock代码总结

class CachedData {
    Object data;
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        rwl.readLock().lock();
        if (!cacheValid) {
        	// Must release read lock before acquiring write lock 
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // Recheck state because another thread might have          
                // acquired write lock and changed state before we did.
                if (!cacheValid) {
                    data = ...;
                    cacheValid = true;
                }
                // Downgrade by acquiring read lock before releasing write lock
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock();
                // Unlock write, still hold read
            }
        } try {
            use(data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

代码声明了一个volatile类型的cacheValid变量，保证可见性，首先获取读锁，如果cache不可用，则释放读锁。获取写锁，在更改数据之前，再检查一遍cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前立刻抢夺获取读锁，此时cache中数据可用，处理cache中的数据，最后释放读锁。这个过程是一个完整的锁降级过程，目的是保证数据的可见性。
总结一句话：同一个线程自己持有写锁时，再去拿读锁，本质相当于重入。
如果违背了锁降级的步骤：当前线程C修改完cache中的数据后，没有获取读锁而是直接释放了写锁，此时另一个线程D获取了写锁并修改了数据，那么C线程取法感知到数据已被修改，读取数据出现错误。
如果遵循锁降级的步骤：线程C释放写锁之前获取读锁，那么线程D在获取写锁时将被阻塞，直到线程C完成数据处理过程，释放写锁。这样可以保证返回的数据是这次更新的数据，该机制是专门为了缓存设计的。

面试题：有没有比对写锁更快的锁

无锁→独占锁→读写锁→邮戳锁。

是什么

StampedLock是JDK1.8中新增的一个读写锁，也是JDK1.5中的读写锁ReentrantReadWriteLock的优化，邮戳锁又叫票据锁，它有一个stamp标记，类型是long类型的。
代表锁的状态，当stamp返回0时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。

它是由锁饥饿问题引出的

ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就比较困难了，当前一直存在读锁，从而无法获取写锁。
如何缓解锁饥饿问题：
使用公平策略，可以一定程度上缓解锁饥饿问题：new ReentrantReadWriteLock(true)，但是这会牺牲吞吐量。
ReentrantReadWriteLock允许多个线程同时读取，但是只允许一个线程写，在线程获取写锁的时候，其他操作和读操作都会处于阻塞状态，读锁和写锁是互斥的，所以在读的时候，不允许写，读写锁比传统的synchronized速度要快很多，原因在于ReentrantReadWriteLock支持读并发，读读可共享。
在ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞，但是StampedLock采取乐观获取锁，其他线程尝试获取写锁不会阻塞，这是对读锁的一个优化，在获取乐观读锁后，还需要对结果进行校验。

StampedLock的特点

所有获取锁的方法，都返回一个邮戳，如果邮戳为0表示获取失败，其余表示获取成功
所有释放锁的方法，都需要一个邮戳，这个邮戳必须是和成功获取锁时得到的邮戳是一致的
StampedLock是不可重入锁，危险：如果一个线程已经持有了写锁，再去获取读锁就会造成死锁
StampLock有三种访问模式：

Reading（读模式悲观）：功能和ReentrantReadWriteLock的读锁类似
Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
Optimistic Reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式

乐观读模式代码演示

import java.util.concurrent.locks.StampedLock;

/**
 * StampedLock=ReentrantReadWriteLock+读的过程中允许写锁介入
 */
public class StampedLockDemo {
    static int number = 1;
    static StampedLock stampedLock = new StampedLock();

    public void write() {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName() + "\t写线程开始修改");
        try {
            number++;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName() + "\t写线程结束修改");
    }

    /**
     * 悲观读，读的过程中不允许写锁进入
     */
    public void gloomyRead() throws InterruptedException {
        long stamp = stampedLock.readLock();
        System.out.println("获取到readlock，开始读取");
        for (int i = 0; i < 4; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "\t正在读取中");
        }
        try {
            int result = number;
            System.out.println("读取完成，结果：" + result);
            System.out.println("写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥");
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

    /**
     * 乐观读，读的过程中允许写锁进入
     */
    public void optimismRead() throws InterruptedException {
        long stamp = stampedLock.tryOptimisticRead();
        int result = number;
        System.out.println("stampedLock.validate()方法：true-无修改 false-有修改");
        System.out.println("stampedLock.validate()=" + stampedLock.validate(stamp));
        // 模拟长时间读取操作
        for (int i = 0; i < 4; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "stampedLock.validate()=" + stampedLock.validate(stamp));
        }
        if (!stampedLock.validate(stamp)) {// 在读取过程中其他线程修改了数据
            System.out.println("在读取过程中其他线程修改了数据");
            stamp = stampedLock.readLock();// 升级为悲观锁
            try {
                System.out.println("乐观锁升级为悲观锁");
                result = number;
                System.out.println("悲观锁读取后result=" + result);
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        System.out.println(Thread.currentThread().getName() + "\tvalue=" + result);
    }

    public static void main(String[] args) throws InterruptedException {
        StampedLockDemo stampedLockDemoe = new StampedLockDemo();
        new Thread(() -> {
            try {
//                stampedLockDemoe.gloomyRead();// 悲观读
                stampedLockDemoe.optimismRead();// 乐观读
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "readThread").start();
        Thread.sleep(1000);
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t写线程开始工作");
            stampedLockDemoe.write();
        }, "writeThread").start();
        Thread.sleep(4000);
        System.out.println(Thread.currentThread().getName() + "\tnumber=" + number);
    }
}

StampedLock的缺点

不支持重入，没有Re开头
悲观读锁和写锁都不支持条件变量
一定不要调用中断操作，不要调用interrupt()操作

王劭阳

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC并发编程与源码分析笔记14-ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

无锁→独占锁→读写锁→邮戳锁无锁：读和写同时进行，会产生大量的错误数据。独占锁（synchronized，Lock接口，ReentrantLock）：此时就将读、写线程进行了有序排列，每次只处理一个请求，不会产生数据错乱，保证了数据一致性读写锁（ReentrantReadWriteLock）：读写互斥，读读共享，适用于读多写少的情况，不过会有写锁饥饿问题和锁降级问题邮戳锁（StampedLock）
复制链接

扫一扫