2022-02-09 Reentrant ReadWrite Stamped Lock区别

这三种锁属于层层递进的关系
互斥
ReentrantLock 每个线程之间都是互斥的；谁lock.lock()住了谁就拥有锁
ReentrantReadWriteLock 读读共享读写互斥写写互斥
如果两个线程同时lock.readLock().lock()，那么他们都可以访问代码，继续往下执行
如果一个线程获取lock.readLock().lock()，在unlock()之前，如果其他线程lock.writeLock().lock()，那么第二个线程将会被阻塞；
StampedLock 这位更是重量级，上边readwrite是悲观锁，拿不到就等，如果有一个场景大量读，然后只有一个线程孤零零的等些写，这种最坏的情况是获取读锁的线程一直占着锁，然后写线程一直和他们在竞争，如果一直抢不到（可能是几万对一个，虽说这几万可能同时就占着锁一秒，还有一种情况就是读线程一直进每个1秒，加入每隔0.2秒进来一批，那么这个锁就一直被读线程们占领，永远别想写了）
这时候出来一个它，提出了一个乐观读的概念，就是在读的同时，写线程也可以进行修改；

public void write() {
        long stamp = lock.writeLock();
        try {
            i++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

stamp就是一个类似mysql乐观锁的版本号，有了这个每次解锁的时候都要提交验证；写有啥可验证的没看出来，读就需要验证了

public void optimisticRead() {
    // 1. 非阻塞乐观读模式获取版本信息
    long stamp = lock.tryOptimisticRead();
    // 2. 拷贝共享数据到线程本地栈中
    copyVaraibale2ThreadMemory();
    // 3. 校验乐观读模式读取的数据是否被修改过
    if (!lock.validate(stamp)) {
        // 3.1 校验未通过，上读锁
        stamp = lock.readLock();
        try {
            // 3.2 拷贝共享变量数据到局部变量
            copyVaraibale2ThreadMemory();
        } finally {
            // 释放读锁
            lock.unlockRead(stamp);
        }
    }
    // 3.3 校验通过，使用线程本地栈的数据进行逻辑操作
    useThreadMemoryVarables();
}

大致就是这个意思，此外
https://zhuanlan.zhihu.com/p/257868603

StampedLock是不可重入锁，使用过程中一定要注意；
悲观读、写锁都不支持条件变量 Conditon ，当需要这个特性的时候需要注意；
如果线程阻塞在 StampedLock 的 readLock() 或者 writeLock() 上时，此时调用该阻塞线程的 interrupt() 方法，会导致 CPU 飙升。所以，使用 StampedLock 一定不要调用中断操作，如果需要支持中断功能，一定使用可中断的悲观读锁 readLockInterruptibly() 和写锁 writeLockInterruptibly()。这个规则一定要记清楚。
反正我也没用过~

刚才说的readwritelock极端的一种情况就是执行两秒，每一秒进一个新线程，导致写锁永远抢不上

public class ReadWriteLock {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int i;

    public static void main(String[] args) {

        ReadWriteLock readWriteLock = new ReadWriteLock();
        //读写
        System.out.println("读写互斥");
        readWriteLock.testReadWrite();
    }
    private void testReadWrite() {
//这个10可以是无限大模拟极端情况
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    read();
                }
            }, i+"号读锁").start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                write();
            }
        }, "t2").start();

    }
}

运行结果
读写互斥
占用read锁的线程名称Thread[0号读锁,5,main]- i=0
占用read锁的线程名称Thread[1号读锁,5,main]- i=0
释放read锁的线程名称Thread[0号读锁,5,main]- i=0
占用read锁的线程名称Thread[2号读锁,5,main]- i=0
释放read锁的线程名称Thread[1号读锁,5,main]- i=0
占用read锁的线程名称Thread[3号读锁,5,main]- i=0
释放read锁的线程名称Thread[2号读锁,5,main]- i=0
占用read锁的线程名称Thread[4号读锁,5,main]- i=0
释放read锁的线程名称Thread[3号读锁,5,main]- i=0
占用read锁的线程名称Thread[5号读锁,5,main]- i=0
释放read锁的线程名称Thread[4号读锁,5,main]- i=0
占用read锁的线程名称Thread[6号读锁,5,main]- i=0
释放read锁的线程名称Thread[5号读锁,5,main]- i=0
占用read锁的线程名称Thread[7号读锁,5,main]- i=0
释放read锁的线程名称Thread[6号读锁,5,main]- i=0
占用read锁的线程名称Thread[8号读锁,5,main]- i=0
释放read锁的线程名称Thread[7号读锁,5,main]- i=0
占用read锁的线程名称Thread[9号读锁,5,main]- i=0
释放read锁的线程名称Thread[8号读锁,5,main]- i=0
释放read锁的线程名称Thread[9号读锁,5,main]- i=0
占用write锁的线程名称Thread[t2,5,main]- i=0
释放write锁的线程名称Thread[t2,5,main]- i=1

2022-02-09 Reentrant ReadWrite Stamped Lock区别

你可能感兴趣的:(2022-02-09 Reentrant ReadWrite Stamped Lock区别)