【JAVA核心知识】21-F.1：ReentrantLock的简单使用

最新推荐文章于 2024-04-18 09:08:30 发布
最新推荐文章于 2024-04-18 09:08:30 发布
阅读量335 收藏
点赞数
分类专栏： JAVA核心知识 JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yue_hu/article/details/118962641
版权

ReentrantLock的简单使用

加锁与解锁

lock()，lockInterruptibly()，tryLock(long timeout, TimeUnit unit)，tryLock()的区别

lock()，tryLock()与unlock()的简单使用：

lock()，lockInterruptibly()，tryLock(long timeout, TimeUnit unit)对中断的反应：

ReentrantLock的其它常用方法

示例代码

关联导航 

ReentrantLock是JDK1.5引入的一个API级别的可重入锁。不同于synchronized仅支持非公平模式，ReentrantLock可以在构造时指定这个锁是公平模式还是非公平模式。除了能实现synchronized所能完成的工作外，还提供了如可响应中断锁，可轮询锁请求，定时锁等避免多线程死锁的方法。

加锁与解锁

lock()，lockInterruptibly()，tryLock(long timeout, TimeUnit unit)，tryLock()的区别

ReentrantLock执行加锁有4个方法，分别为lock()，lockInterruptibly()，tryLock(long timeout, TimeUnit unit)，tryLock()，4个方法的区别为：

  • lock()： 一直等待锁，无视中断，在获取锁过程中即使线程遭遇中断也不会管，而是继续等下去，获得锁之后线程继续执行而不是中断
  • lockInterruptibly()：一直等待锁，考虑中断，获取锁过程中如果线程遭遇中断，则中断等待，则抛出InterruptedException，因此要求必须需要捕获InterruptedException
  • tryLock(long timeout, TimeUnit unit)： 指定时间等待锁，指定时间获取锁成功返回true，获取失败返回false。等待时间内考虑中断，等待过程中如果遭遇中断会抛出InterruptedException，因此要求必须需要捕获InterruptedException
  • tryLock()： 直接获取锁，成功返回true，获取失败返回false。等价于tryLock(0, TimeUnit unit);

ReentrantLock执行解锁均使用unlock()方法，unlock()必须由持有锁的线程执行，否则抛出IllegalMonitorStateException。为了避免死锁，unlock()最好放在finally块内。因为ReentrantLock是一个可重入锁，因此一个线程可能进行了多次加锁，但是unlock()执行一次仅解锁一次，也就是说持有锁的线程加了多少次锁，也要用unlock()解锁多少次，否则锁依然不会被释放！

lock()，tryLock()与unlock()的简单使用：

public class SimReentrantLock {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t1获取锁");
                    lock.lock(); // 加锁
                    System.out.println("t1拿到锁");
                    System.out.println("1号逻辑");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("1error");
                    e.printStackTrace();
                } finally {
                    lock.unlock(); // 解锁
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                boolean tryFlag = lock.tryLock();
                System.out.println("t2用tryLock获取锁的标识:" + tryFlag);
                if (!tryFlag) {
                    try {
                        System.out.println("t2用lock获取锁");
                        lock.lock();
                        System.out.println("t2拿到锁");
                    } catch (Exception e) {
                        System.out.println("2error");
                        e.printStackTrace();
                    } finally {
                        lock.unlock(); // 解锁
                    }
                } else {
                    System.out.println("t2用tryLock拿到了锁");
                    lock.unlock(); // 解锁
                }
            }
        });
        t1.start();
        try {
            Thread.sleep(10); // 这里睡眠一下保证1号线程先拿到锁
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        t2.start();
    }

}

运行结果：

t1获取锁
t1拿到锁
1号逻辑
t2用tryLock获取锁的标识:false
t2用lock获取锁
t2拿到锁

lock()，lockInterruptibly()，tryLock(long timeout, TimeUnit unit)对中断的反应：

public class LockAndLockInterruptibly {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t1获取锁");
                    lock.lock(); // 加锁
                    System.out.println("t1拿到锁");
                    System.out.println("1号逻辑");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("1error");
                    e.printStackTrace();
                } finally {
                    lock.unlock(); // 解锁
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    System.out.println("t2获取锁");
                    lock.lock();// 一直等待锁，无视中断，在获取锁过程中即使线程遭遇中断也不会管，而是继续等下去，获得锁之后线程继续执行而不是中断
//                    lock.lockInterruptibly(); // 一直等待锁，考虑中断，获取锁过程中如果线程遭遇中断，则中断等待，则抛出InterruptedException，因此要求必须需要捕获InterruptedException
//                    lock.tryLock(200, TimeUnit.MILLISECONDS);// 指定时间等待锁，指定时间获取锁成功返回true，获取失败返回false。等待时间内考虑中断，等待过程中如果遭遇中断会抛出InterruptedException，因此要求必须需要捕获InterruptedException
                    System.out.println("t2拿到锁");
                    System.out.println("2号逻辑");
                } catch (Exception e) {
                    System.out.println("2error");
                    e.printStackTrace();// 这个地方打出来的异常有些许不同
                } finally {
                    lock.unlock(); // 解锁
                }
            }
        });
        t1.start();
        try {
            Thread.sleep(10); // 因为用2号线程测试lock(),lockInterruptibly(),tryLock()的区别，所以这里睡眠一下保证1号线程先拿到锁
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        t2.start();
        try {
            Thread.sleep(10); // 2号线程睡一下保证运行到lock(),lockInterruptibly(),tryLock()
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        t2.interrupt(); // 2号线程执行中断
    }
}

2号线程使用lock()的运行结果：

t1获取锁
t1拿到锁
1号逻辑
t2获取锁
t2拿到锁
2号逻辑  // 可以看到无视了中断,拿到锁执行了2号逻辑

2号线程使用lockInterruptibly()的运行结果：

t1获取锁
t1拿到锁
1号逻辑
t2获取锁
2error  // 可以看到2号线程响应了中断并抛出了InterruptedException
java.lang.InterruptedException

2号线程使用tryLock(long timeout, TimeUnit unit)的运行结果：

t1获取锁
t1拿到锁
1号逻辑
t2获取锁
2error // 可以看到在等待时间内响应了中断并抛出了InterruptedException
java.lang.InterruptedException

ReentrantLock的其它常用方法

  • int getHoldCount()：当前锁的加锁次数，如果无线程持有锁就返回0
  • int getQueueLength()： 当前竞争此锁队列长度
  • int getWaitQueueLength(Condition condition)： 当前锁等待队列长度。需要与Condition联合使用
  • boolean isFair()： 是否是公平锁
  • boolean isLocked()： 当前锁是否处于锁定状态
  • boolean isHeldByCurrentThread()： 当前锁是否被当前线程持有
  • boolean hasWaiters(Condition condition)： 当前condition是否有线程在等待，需要与Condition联合使用
  • boolean hasQueuedThread(Thread thread)： 目标线程是否在这个锁的竞争队列中
  • boolean hasQueuedThreads()： 是否有线程在当前锁的竞争队列中

示例代码

public class OtherMethodOfRTL {
    public static void main(String[] args) {
        final ReentrantLock lock = new ReentrantLock();
        final Condition c = lock.newCondition();
        
        final Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("T1得到锁");
                    System.out.println("T1开始等待");
                    c.await();
                    System.out.println("T1收到信号");
                    System.out.println("T1发出信号");
                    c.signal();
                } catch (InterruptedException e) {
                    System.out.println("1error");
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        for (int i = 0; i < 3; i++) {
            final int j = i;
            final Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        lock.lock();
                        System.out.println(j + "拿到锁");
                        System.out.println("持有加锁次数：" + lock.getHoldCount());
                        System.out.println("当前竞争此锁队列长度：" + lock.getQueueLength());
                        System.out.println("当前锁等待队列长度：" + lock.getWaitQueueLength(c));
                        System.out.println("是否是公平锁：" + lock.isFair());
                        System.out.println("当前锁是否有线程持有：" + lock.isLocked());
                        System.out.println("当前锁是否被当前线程持有：" + lock.isHeldByCurrentThread());
                        System.out.println("当前condition是否有线程在等待：" + lock.hasWaiters(c));
                        System.out.println("目标线程是否在这个锁的竞争队列中：" + lock.hasQueuedThread(t1));
                        System.out.println("是否有线程在当前锁的竞争队列中：" + lock.hasQueuedThreads());
                        System.out.println(j + "等待信号");
                        c.await(); 
                        System.out.println(j + "收到信号");
                        System.out.println("当前condition是否有线程在等待：" + lock.hasWaiters(c));
                        System.out.println("目标线程是否在这个锁的竞争队列中：" + lock.hasQueuedThread(t1));
                        System.out.println("是否有线程在当前锁的竞争队列中：" + lock.hasQueuedThreads());
                        System.out.println(j + "发出信号");
                        c.signal();
                    } catch (Exception e) {
                        System.out.println("2error");   
                        e.printStackTrace();   
                    } finally {
                        lock.unlock(); // 一定记得要解锁！！！
                    }
                }
            });
            t.start();
        }
        
        t1.start();
        lock.lock();
        System.out.println("主线程拿到锁");
        try {
            Thread.sleep(100); // 睡一下保证确实有线程在等待了,免得线程都没到wait,唤醒了个寂寞
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程发出信号");
        c.signal();   // 唤醒
        System.out.println("主线程释放锁");
        lock.unlock();
    }
}

运行结果：

0拿到锁
持有加锁次数：1
当前竞争此锁队列长度：4
当前锁等待队列长度：0
是否是公平锁：false
当前锁是否有线程持有：true
当前锁是否被当前线程持有：true
当前condition是否有线程在等待：false
目标线程是否在这个锁的竞争队列中：true
是否有线程在当前锁的竞争队列中：true
0等待信号
2拿到锁
持有加锁次数：1
当前竞争此锁队列长度：3
当前锁等待队列长度：1
是否是公平锁：false
当前锁是否有线程持有：true
当前锁是否被当前线程持有：true
当前condition是否有线程在等待：true
目标线程是否在这个锁的竞争队列中：true
是否有线程在当前锁的竞争队列中：true
2等待信号
1拿到锁
持有加锁次数：1
当前竞争此锁队列长度：2
当前锁等待队列长度：2
是否是公平锁：false
当前锁是否有线程持有：true
当前锁是否被当前线程持有：true
当前condition是否有线程在等待：true
目标线程是否在这个锁的竞争队列中：true
是否有线程在当前锁的竞争队列中：true
1等待信号
主线程拿到锁
主线程发出信号
主线程释放锁
T1得到锁
T1开始等待
0收到信号
当前condition是否有线程在等待：true
目标线程是否在这个锁的竞争队列中：false
是否有线程在当前锁的竞争队列中：false
0发出信号
2收到信号
当前condition是否有线程在等待：true
目标线程是否在这个锁的竞争队列中：false
是否有线程在当前锁的竞争队列中：false
2发出信号
1收到信号
当前condition是否有线程在等待：true
目标线程是否在这个锁的竞争队列中：false
是否有线程在当前锁的竞争队列中：false
1发出信号
T1收到信号
T1发出信号

关联导航 

【JAVA核心知识】系列导航 [持续更新中…]
关联导航：22-F.1：Condition的简单使用
关联导航：21：从源码看ReentrantLock
欢迎关注…

yue_hu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java中的显示锁ReentrantLock使用与原理详解
08-26
主要介绍了Java中的显示锁ReentrantLock使用与原理详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
joeylv#joscrapy#【Java并发编程实战】-----“J.U.C”：ReentrantLock之三unlock方法
07-25
当然在release()方法中不仅仅只是将state- 1这么简单，- 1之后还需要进行一番处理，如果-1之后的新state = 0，则表示当前锁已经被线程释放
ReentrantLock可重入独占锁详解
m0_73311735的博客
06-05 471
位于包下，是Lock接口的实现类。基本用法与相似，都具备可重入互斥的特性，但拥有更强大的且灵活的锁机制。class X {//定义锁对象// ...//定义需要保证线程安全的方法//加锁try{// 保证线程安全的代码// 使用finally块保证释放锁finally {API层面的独占锁：ReentrantLock是底层使用AQS实现的可重入的独占锁，区别于synchronized原生语法层面实现锁语义，ReetrantLock通过lock()和unlock()
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3029
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
Java~多线程ReentrantLock类常用的十四个方法, 使用Condition实现多线程的顺序执行
最新发布
2401_84408378的博客
04-18 968
JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC，网络，日志，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算…《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
JAVA ReentrantLock的使用
weixin_34402408的博客
08-11 109
源码如下 对比synchronized，synchronized使用时会显示的指定一个对象(方法为调用对象，代码块会需要对象作为参数)，来获取一个对象的独占锁 而ReentrantLock可能就是使用的ReentrantLock对象的独占锁来实现锁的功能，所以不同线程要用同一个ReentrantLock对象来互斥 public static void main(Stri...
[Java]ReentrantLock的使用
qq_61925446的博客
05-06 710
在实际的编程中，代码往往有很多分支，调用了lock之后必须要调用unlock其他地方才能调用lock加锁，但是由于需要手动解锁，所以很有可能忘了unlock，为保证每个lock都能被unlock，使用trycatch中的finally代码块来确保最后都会释放锁。普通的lock方法如果有其他线程已经lock了，那线程就会阻塞并死等，但是使用trylock方法，就只会尝试加锁，然后返回true或者false来表明是否加锁成功，加锁失败就放弃加锁，也不死等。（3）提供了公平锁的版本。
Java ReentrantLock使用
weixin_43270731的博客
03-21 589
Java ReentrantLock使用
java中ReentrantLock的使用
m0_50163856的博客
03-29 1078
ReentrantLock(互斥锁，可重入锁) 使用： ReentrantLock reentrantLock = new ReentrantLock(); reentrantLock.lock();//拿锁 boolean res = reentrantLock.tryLock();//拿到锁返回true,没拿到返回false boolean res = reentrantLock.tryLock(100,TimeUnit.SECONDS);//100秒内拿到锁返回true,否则没拿到返回false re
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
主要介绍了java（JUC）ReentrantLock的的相关资料，文中讲解非常详细，实例代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
Java 多线程与并发(11_26)-JUC锁_ ReentrantLock详解
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
Java多线程并发的程序中使用互斥锁有synchronized和ReentrantLock两种方式,这里我们来详解Java多线程编程中互斥锁ReentrantLock类的用法:
java核心知识点整理.pdf
04-19
目录 .........................................................................................................................................................1 JVM ......................................
contention-profiling:ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
06-10
争用分析 ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
Java中ReentrantLock的使用
热门推荐
black_bird_cn的博客
08-25 1万+
一、基本概念 可重入锁:也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。 在JAVA中ReentrantLock 和synchronized 都是可重入锁； 重入锁ReentrantLock 相对来说是synchronized、Object.wait()和Object.notify()方法的替代品(或者说是增强版)，在JDK5.0的早期...
java并发编程学习四——ReentrantLock使用
yx444535180的专栏
09-05 374
可中断意思是，在获取lock失败之后，线程进入lock的阻塞队列，再调用了线程的interrupt方法之后，线程将被中断，不再阻塞并抛出异常InterruptedException。使用ReentrantLock的tryLock(n,TimeUnit)方法，可以设定等待锁的时间，等待期间也可以被interrupt方法打断。看示例代码，t1线程要先睡觉再工作，t2线程要先工作再睡觉就发生了死锁。三个线程t1/t2/t3，t1输出五次a，t2输出5次b，t3输出5次c；执行的结果，程序不能正常退出。
java ReentrantLock 使用
JHON07的博客
05-13 175
1.ReentrantLock 简单的使用 private Lock lock = new ReentrantLock(); lock.lock();用来获取锁。 lock.unlock();用来释放锁 package com.qey.lock; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecu.
java ReentrantLock应用
jie310600的博客
09-26 203
[b]java ReentrantLock应用[/b] ReentrantLock可重入锁 1.使用ReentrantLock接口要比使用synchronized关键字效率高一些 [b]不公平锁与公平锁的区别：[/b] [code="java"]private ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平...
Java：Java学习笔记之ReentrantLock的简单理解和使用
JMW1407的博客
01-21 3458
ReentrantLock ReentrantLock1、相关知识1.1 公平锁和非公平锁1.2 可重入锁1.3、CAS算法2、背景、定义和特征2.1、背景2.2、定义2.3、特征3、基本结构4、基本使用4.1、解决背景问题4.2、重入锁 使用4.3、公平锁使用5、源码分析5.1、AQS5.2、非公平锁的实现原理5.2.1、lock方法获取锁:tryAcquire5.2.2、锁的释放:tryRelease5.3、公平锁的实现原理5.3.1、lock方法获取锁:tryAcquire5.3.2、锁的释放:try
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
01-05
`at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)`是Java中`ReentrantLock`类的`Sync`内部类的`tryRelease`方法的调用。该方法用于尝试释放锁。 `ReentrantLock`是Java中的一个可重入锁，它提供了比`synchronized`关键字更灵活的锁定机制。`ReentrantLock`的`tryRelease`方法是用来释放锁的，它会尝试释放当前线程持有的锁。 在你提供的引用中，`tryRelease`方法的调用发生在`IntLock`类的`run`方法中。具体的调用路径是`IntLock.run()` -> `ReentrantLock.lockInterruptibly()` -> `ReentrantLock.Sync.tryRelease()`。 需要注意的是，`tryRelease`方法的具体实现是在`Sync`内部类中，而不是`ReentrantLock`类本身。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yue_hu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值