可重入锁、读写锁、邮戳锁 详解

文章目录

  • 1、可重入锁(递归锁)
  • 2、读写锁
    • 2.1、读写分离
    • 2.2、从写锁到读锁,ReentrantReadWriteLock可以降级
    • 2.3、写锁和读锁是互斥的
  • 3、邮戳锁StampedLock
    • 3.1、是什么
    • 3.2、锁饥饿
    • 3.3、如何缓解锁饥饿问题呢
      • 3.3.1、使用“公平”策略
      • 3.3.2、StampedLock类的乐观锁
    • 3.4、StampedLock的特点
    • 3.5、StampedLock的三种访问模式
    • 3.6、StampedLock的缺点

1、可重入锁(递归锁)

可重入锁是一种技术: 任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞。

可重入锁的原理: 通过组合自定义同步器来实现锁的获取与释放。

  • 再次获取锁:识别获取锁的线程是否为当前占据锁的线程,如果是,则再次成功获取。获取锁后,进行计数自增
  • 释放锁:释放锁时,进行计数自减。

Java中的可重入锁: ReentrantLock、synchronized修饰的方法或代码段。

可重入锁的作用: 避免死锁

面试题1: 可重入锁如果加了两把,但是只释放了一把会出现什么问题? 答:程序卡死,线程不能出来,也就是说我们申请了几把锁,就需要释放几把锁。

面试题2: 如果只加了一把锁,释放两次会出现什么问题? 答:会报错,java.lang.IllegalMonitorStateException

可重入锁、读写锁、邮戳锁 详解_第1张图片

2、读写锁

2.1、读写分离

读写锁定义为一个资源能够被多个读线程访问,或者被一个写线程访问,但是不能同时存在读写线程 读写分离、可重入

读写锁 通过ReentrantReadWriteLock类来实现 ,只允许读读共存读写互斥

为了提高性能,Java 提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,灵活控制,如果没有写锁的情况下,读是无阻塞的,在一定程度上提高了程序的执行效率。 读写锁分为读锁 和写锁,多个读锁不互斥读锁与写锁互斥,这是由 jvm 自己控制的。

读锁: 允许多个线程获取读锁,同时访问同一个资源。

写锁: 只允许一个线程获取写锁,不允许同时访问同一个资源。

可重入锁、读写锁、邮戳锁 详解_第2张图片

举个栗子加深理解:

class MyResource
{
    Map<String,String> map = new HashMap<>();
    //=====ReentrantLock 等价于 =====synchronized
    //Lock lock = new ReentrantLock();
    //=====ReentrantReadWriteLock 一体两面,读写互斥,读读共享
    ReentrantReadWriteLock 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 result = map.get(key);
            //后续开启注释修改为2000,演示一体两面,读写互斥,读读共享,读没有完成时候写锁无法获得
            //try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"---完成读取result:"+result);
        }finally {
            rwLock.readLock().unlock();
        }
    }
}

public class ReentrantReadWriteLockDemo
{
    public static void main(String[] args)
    {
        MyResource myResource = new MyResource();

        for (int i = 1; i <=10; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.write(finalI +"", finalI +"");
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <=10; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.read(finalI +"");
            },String.valueOf(i)).start();
        }

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        //读全部over才可以继续写
        for (int i = 1; i <=3; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.write(finalI +"", finalI +"");
            },"newWriteThread==="+String.valueOf(i)).start();
        }
    }
    /**
     * 运行结果:
     * 3   ---正在写入
     * 3   ---完成写入
     * 4   ---正在写入
     * 4   ---完成写入
     * 1   ---正在写入
     * 1   ---完成写入
     * 2   ---正在写入
     * 2   ---完成写入
     * 5   ---正在写入
     * 5   ---完成写入
     * 6   ---正在写入
     * 6   ---完成写入
     * 7   ---正在写入
     * 7   ---完成写入
     * 8   ---正在写入
     * 8   ---完成写入
     * 9   ---正在写入
     * 9   ---完成写入
     * 10  ---正在写入
     * 10  ---完成写入
     * 1   ---正在读取
     * 1   ---完成读取result:1
     * 2   ---正在读取
     * 3   ---正在读取
     * 5   ---正在读取
     * 5   ---完成读取result:5
     * 2   ---完成读取result:2
     * 10  ---正在读取
     * 10  ---完成读取result:10
     * 4   ---正在读取
     * 8   ---正在读取
     * 8   ---完成读取result:8
     * 9   ---正在读取
     * 9   ---完成读取result:9
     * 7   ---正在读取
     * 7   ---完成读取result:7
     * 6   ---正在读取
     * 6   ---完成读取result:6
     * 3   ---完成读取result:3
     * 4   ---完成读取result:4
     * newWriteThread===3  ---正在写入
     * newWriteThread===3  ---完成写入
     * newWriteThread===2  ---正在写入
     * newWriteThread===2  ---完成写入
     * newWriteThread===1  ---正在写入
     * newWriteThread===1  ---完成写入
     *
     * Process finished with exit code 0
     */
}

2.2、从写锁到读锁,ReentrantReadWriteLock可以降级

锁降级:遵循获取写锁获取读锁释放写锁,写锁能够降级为读锁

一句话,将写锁降级为读锁

如果一个线程占有了写锁,在不释放写锁的情况下,它还能占有读锁,即写锁降级为读锁。

可重入锁、读写锁、邮戳锁 详解_第3张图片

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

举个栗子:

/**
 * 锁降级:遵循获取写锁→再获取读锁→再释放写锁的次序,写锁能够降级成为读锁。
 *
 * 如果一个线程占有了写锁,在不释放写锁的情况下,它还能占有读锁,即写锁降级为读锁。
 */
public class LockDownGradingDemo
{
    public static void main(String[] args)
    {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

        writeLock.lock();
        System.out.println("-------正在写入");
        //此时没有释放写锁就获取读锁
        readLock.lock();
        System.out.println("-------正在读取");

        writeLock.unlock();
    }
    /**
     * 运行结果:
     * -------正在写入
     * -------正在读取
     *
     * Process finished with exit code 0
     */
}

线程获取读锁是不能直接升级为写入锁的,也就是说可以写锁降级为读锁,不可逆

可重入锁、读写锁、邮戳锁 详解_第4张图片

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

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

2.3、写锁和读锁是互斥的

(这里的互斥是指线程间的互斥,当前线程可以获取到写锁又获取到读锁,但是获取到了读锁不能继续获取写锁),这是因为读写锁要保持写操作的可见性

因为,如果允许读锁在被获取的情况下对写锁的获取,那么正在运行的其他读线程无法感知到当前写线程的操作,可能会出现脏读。

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

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

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

也就是写入必须等待,这是一种悲观的读锁,o(╥﹏╥)o,人家还在读着那,你先别去写,省的数据乱

有没有比读写锁更快的锁?

3、邮戳锁StampedLock

无锁、独占锁、读写锁、邮戳锁

3.1、是什么

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

stamp 戳记 ,代表了锁的状态,当stamp返回 0 时 ,表示线程获取锁失败,当释放锁或者转换锁的时候,都要传入最初获取的 stamp 值

3.2、锁饥饿

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

假如当前1000个线程,999个读,1个写,有可能999个读取线程长时间抢到了锁,那1个写线程就悲剧了

因为当前有可能会一直存在读锁,而无法获得写锁,根本没机会写,o(╥﹏╥)o

3.3、如何缓解锁饥饿问题呢

3.3.1、使用“公平”策略

使用“公平”策略可以一定程度上缓解锁饥饿问题,但是会牺牲系统吞吐量为代价

new ReentrantReadWriteLock(true)

3.3.2、StampedLock类的乐观锁

  • ReentrantReadWriteLock

允许多个线程同时读,但是只允许一个线程写,在线程获取到写锁的时候,其他写操作和读操作都会处于阻塞状态,

读锁和写锁也是互斥的,所以在读的时候是不允许写的,读写锁比传统的synchronized速度要快很多,

原因就是在于ReentrantReadWriteLock支持读并发

  • StampedLock横空出世

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

但是,StampedLock采取乐观获取锁后,其他线程尝试获取写锁时不会被阻塞,这其实是对读锁的优化,

所以,在获取乐观读锁后,还需要对结果进行校验

3.4、StampedLock的特点

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

3.5、StampedLock的三种访问模式

  • Reading(读模式):功能和ReentrantReadWriteLock的读锁类似
  • Writing(写模式):功能和ReentrantReadWriteLock的写锁类似
  • Optimistic reading (乐观读模式):无锁机制,类似于数据库中的乐观锁,支持读写并发,很乐观的认为读操作时没有人来修改,假如被修改再升级为悲观锁模式

乐观读模式小栗子:读的过程中允许写锁介入

public class StampedLockDemo
{
    static int number = 37;
    static StampedLock stampedLock = new StampedLock();

    public void write()
    {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程准备修改");
        try
        {
            number = number + 13;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");

    }

    //悲观读
    public void read()
    {
        long stamp = stampedLock.readLock();
        System.out.println(Thread.currentThread().getName()+"\t come in readlock block,4 seconds continue...");
        //暂停几秒钟线程
        for (int i = 0; i <4 ; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......");
        }
        try
        {
            int result = number;
            System.out.println(Thread.currentThread().getName()+"\t"+" 获得成员变量值result:" + result);
            System.out.println("写线程没有修改值,因为 stampedLock.readLock()读的时候,不可以写,读写互斥");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockRead(stamp);
        }
        System.out.println(Thread.currentThread().getName()+"\t finally value: "+number);
    }

    //乐观读
    public void tryOptimisticRead()
    {
        long stamp = stampedLock.tryOptimisticRead();
        int result = number;
        //间隔4秒钟,我们很乐观的认为没有其他线程修改过number值,实际靠判断。
        System.out.println("4秒前stampedLock.validate值(true无修改,false有修改)"+"\t"+stampedLock.validate(stamp));
        for (int i = 1; i <=4 ; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......"+i+
                    "秒后stampedLock.validate值(true无修改,false有修改)"+"\t"
                    +stampedLock.validate(stamp));
        }
        if(!stampedLock.validate(stamp)) {
            System.out.println("有人动过--------存在写操作!");
            stamp = stampedLock.readLock();
            try {
                System.out.println("从乐观读 升级为 悲观读");
                result = number;
                System.out.println("重新悲观读锁通过获取到的成员变量值result:" + result);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                stampedLock.unlockRead(stamp);
            }
        }
        System.out.println(Thread.currentThread().getName()+"\t finally value: "+result);

    }

    public static void main(String[] args)
    {
        StampedLockDemo resource = new StampedLockDemo();

        new Thread(() -> {
            //resource.read();
            resource.tryOptimisticRead();
        },"readThread").start();

        // 2秒钟时乐观读失败,6秒钟乐观读取成功resource.tryOptimisticRead();,修改切换演示
        try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            resource.write();
        },"writeThread").start();

    }
    /**
     * 运行过程:
     * 悲观读情况:
     * readThread   come in readlock block,4 seconds continue...
     * readThread   正在读取中......
     * readThread   正在读取中......
     * readThread   正在读取中......
     * readThread   正在读取中......
     * readThread   获得成员变量值result:37
     * 写线程没有修改值,因为 stampedLock.readLock()读的时候,不可以写,读写互斥
     * writeThread =====写线程准备修改
     * writeThread =====写线程结束修改
     *
     * 进程已结束,退出代码0
     * --------------------------------------------------------------------
     * 乐观读情况:
     * 4秒前stampedLock.validate值(true无修改,false有修改)  true
     * readThread   正在读取中......1秒后stampedLock.validate值(true无修改,false有修改) true
     * readThread   正在读取中......2秒后stampedLock.validate值(true无修改,false有修改) true
     * readThread   正在读取中......3秒后stampedLock.validate值(true无修改,false有修改) true
     * readThread   正在读取中......4秒后stampedLock.validate值(true无修改,false有修改) true
     * readThread   finally value: 37
     * main最终值37
     * writeThread =====写线程准备修改
     * writeThread =====写线程结束修改
     *
     * 进程已结束,退出代码0
     */
}

3.6、StampedLock的缺点

StampedLock不支持重入,没有Re开头

StampedLock的悲观读锁和写锁都不支持条件变量(Condition)

使用StampedLock 一定不要调用中断操作,即不要调用 interrupt()方法

如果需要支持中断功能,一定使用可中断的悲观读锁readLockInterruptibly()写锁writeLockInterruptibly()

你可能感兴趣的:(jvm,java,开发语言)