Java中的可重入锁ReentrantLock简析

更新时间：2023年12月16日 09:23:38 作者：小晨想好好学习

这篇文章主要介绍了Java中的可重入锁ReentrantLock简析,可重入是指同一个线程如果首次获得了这把锁,那么因为它是这把锁的拥有者,因此有权利再次获取这把锁如果是不可重入锁,那么第二次获得锁时,自己也会被锁挡住,需要的朋友可以参考下

可重入锁ReentrantLock

相对于 synchronized 它具备如下特点

可中断
可以设置超时时间
可以设置为公平锁
支持多个条件变量
与 synchronized 一样，都支持可重入

//基本语法
    // 获取锁
    reentrantLock.lock();
    try{
        // 临界区
    } finally{
        // 释放锁
        reentrantLock.unlock();
    }

1、可重入

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

@Slf4j(topic = "c.TestReentrant")
public class TestReentrant {
    static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        method1();
    }
    public static void method1() {
        lock.lock();
        try {
            log.debug("execute method1");
            method2();
        } finally {
            lock.unlock();
        }
    }
    public static void method2() {
        lock.lock();
        try {
            log.debug("execute method2");
            method3();
        } finally {
            lock.unlock();
        }
    }
    public static void method3() {
        lock.lock();
        try {
            log.debug("execute method3");
        } finally {
            lock.unlock();
        }
    }
}

由结果可以证明：ReentrantLock 是可重入的

在这里插入图片描述

2、可打断

举例说明：

@Slf4j(topic = "c.TestInterrupt")
public class TestInterrupt {
    public static void main(String[] args) {
        test1();
    }
    private static void test1() {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            try {
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("等锁的过程中被打断");
                return;
            }
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(1);
            t1.interrupt();
            log.debug("执行打断");
        } finally {
            lock.unlock();
        }
    }
}

由结果可以看到，main线程获取到了锁，t1线程尝试去获取锁，然后main线程打断t1线程尝试获取锁的过程

在这里插入图片描述

注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断

@Slf4j(topic = "c.TestInterrupt")
public class TestInterrupt {
    public static void main(String[] args) {
        test2();
    }
    private static void test2() {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            lock.lock();
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(1);
            t1.interrupt();
            log.debug("执行打断");
            sleep(1);
        } finally {
            log.debug("释放了锁");
            lock.unlock();
        }
    }
}

可以看到t1被主线程打断后，并没异常抛出错误，而是正常执行

在这里插入图片描述

3、锁超时

1）立即失败的场景

public class TestTimeout {
    public static void main(String[] args) {
        test2();
    }
    private static void test2() {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            if (!lock.tryLock()) {
                 log.debug("获取立刻失败，返回");
                return;
            }
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(2);
        } finally {
            lock.unlock();
        }
    }
}

main线程首先获取到了锁，t1线程尝试去获取锁的时候就会立即失败

在这里插入图片描述

2）超时失败

public class TestTimeout {
    public static void main(String[] args) {
        test1();
    }
    private static void test1() {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            try {
                if (!lock.tryLock(1, TimeUnit.SECONDS)) {
                    log.debug("获取等待 1s 后失败，返回");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(2);
        } finally {
            lock.unlock();
        }
    }
}

由结果可以判断t1线程在尝试获取锁时，阻塞了一秒钟，一秒后还是没有获取到锁，则返回false

在这里插入图片描述

4、公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁，ReentrantLock 默认是不公平的

demo演示证明：ReentrantLock 默认是不公平的

public class TestFair {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock(false);
        lock.lock();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " running...");
                } finally {
                    lock.unlock();
                }
            }, "t" + i).start();
        }
// 1s 之后去争抢锁
        Thread.sleep(1000);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " running...");
                } finally {
                    lock.unlock();
                }
            }, "强行插入").start();
        }
        lock.unlock();
    }
}

按道理说，500个线程是先启动的，应该先获取到锁，但是实际情况，强制插入线程中途就获取到锁了

在这里插入图片描述

5、条件变量

synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待 ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比

synchronized 是那些不满足条件的线程都在一间休息室等消息
而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒

使用要点：

await 前需要获得锁
await 执行后，会释放锁，进入 conditionObject 等待
await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
竞争 lock 锁成功后，从 await 后继续执行

@Slf4j(topic = "c.TestCondition")
public class TestCondition {
    static ReentrantLock lock = new ReentrantLock();
    static Condition waitCigaretteQueue = lock.newCondition();
    static Condition waitbreakfastQueue = lock.newCondition();
    static volatile boolean hasCigrette = false;
    static volatile boolean hasBreakfast = false;
    public static void main(String[] args) {
        new Thread(() -> {
            try {
                lock.lock();
                log.debug("准备工作，看看有没有烟： {}", hasCigrette);
                while (!hasCigrette) {
                    log.debug("准备工作，看看有没有烟： {}", hasCigrette);
                    try {
                    	// 释放锁，并在该条件变量上等待
                        waitCigaretteQueue.await(); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("等到了它的烟");
            } finally {
                lock.unlock();
            }
        }).start();
        new Thread(() -> {
            try {
                lock.lock();
                log.debug("准备工作，看看有没有早餐： {}", hasBreakfast);
                while (!hasBreakfast) {
                    log.debug("准备工作，看看有没有早餐： {}", hasBreakfast);
                    try {
                        waitbreakfastQueue.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("等到了它的早餐");
            } finally {
                lock.unlock();
            }
        }).start();
        sleep(1);
        sendBreakfast();
        sleep(1);
        sendCigarette();
    }
    private static void sendCigarette() {
        lock.lock();
        try {
            log.debug("送烟来了");
            hasCigrette = true;
            waitCigaretteQueue.signal();
        } finally {
            lock.unlock();
        }
    }
    private static void sendBreakfast() {
        lock.lock();
        try {
            log.debug("送早餐来了");
            hasBreakfast = true;
            waitbreakfastQueue.signal();
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

到此这篇关于Java中的可重入锁ReentrantLock简析的文章就介绍到这了,更多相关可重入锁ReentrantLock内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

mybatis使用foreach语句实现IN查询(三种)
这篇文章主要介绍了mybatis使用foreach语句实现IN查询(三种)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-12-12
Java装饰者模式的深入了解
这篇文章主要为大家介绍了Java装饰者模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
2022-01-01
MyBatis动态sql查询及多参数查询方式
这篇文章主要介绍了MyBatis动态sql查询及多参数查询方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-10-10
springcloud本地调试feign调用出现的诡异404问题及解决
这篇文章主要介绍了springcloud本地调试feign调用出现的诡异404问题及解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-03-03
Java将CSV的数据发送到kafka的示例
这篇文章主要介绍了Java将CSV的数据发送到kafka得示例，帮助大家更好得理解和使用Java，感兴趣的朋友可以了解下
2020-11-11
SpringBoot中@ComponentScan注解过滤排除不加载某个类的3种方法
这篇文章主要给大家介绍了关于SpringBoot中@ComponentScan注解过滤排除不加载某个类的3种方法,文中通过实例代码介绍的非常详细,对大家学习或者使用SpringBoot具有一定的参考学习价值,需要的朋友可以参考下
2023-07-07
EasyExcel实现读取excel中的日期单元格并自动判定终止读取
这篇文章主要为大家详细介绍了EasyExcel如何实现读取excel中的日期单元格并自动判定终止读取,感兴趣的小伙伴可以跟随小编一起学习一下
2024-11-11
Java中的List集合初始化及常见方法解析
这篇文章主要介绍了Java中的List集合初始化及常见方法解析,List集合的特点是元素有序可重复,只要是带集合、数组的都叫有序,因若无序就不会存在有下标,本文来讲一下List集合初始化及常见方法,需要的朋友可以参考下
2023-10-10
Java中使用opencv的问题
这篇文章主要介绍了Java中使用opencv的问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-10-10
Java读写ini文件代码示例
这篇文章主要介绍了Java读写ini文件代码示例，分享了相关代码示例及相关注释，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
2018-02-02