Java 重入锁 ReentrantLock

2024年1月9日 252次阅读 来源: 平林新袖

本篇博客是转过来的。 但是略有改动感谢 http://my.oschina.net/noahxiao/blog/101558

摘要

从使用场景的角度出发来介绍对ReentrantLock的使用，相对来说容易理解一些。

场景1：如果发现该操作已经在执行中则不再执行（有状态执行）

a、用在定时任务时，如果任务执行时间可能超过下次计划执行时间，确保该有状态任务只有一个正在执行，忽略重复触发。
b、用在界面交互时点击执行较长时间请求操作时，防止多次点击导致后台重复执行（忽略重复触发）。

以上两种情况多用于进行非重要任务防止重复执行，（如：清除无用临时文件，检查某些资源的可用性，数据备份操作等）

 1 private ReentrantLock lock = new ReentrantLock();
 2     
 3                 if (lock.tryLock()) {  //如果已经被lock，则立即返回false不会等待，达到忽略操作的效果 
 4  
 5                     try {
 6  
 7                        //操作
 8  
 9                     } finally {
10                         lock.unlock();
11                     }
12  
13                 }

e.g 比如一个下载按钮，点击了之后，在还未获取资源之前是不允许进行二次点击下载的。

场景2：如果发现该操作已经在执行，等待结束执行（同步执行，类似synchronized）

这种比较常见大家也都在用，主要是防止资源使用冲突，保证同一时间内只有一个操作可以使用该资源。
但与synchronized的明显区别是性能优势（伴随jvm的优化这个差距在减小）。同时Lock有更灵活的锁定方式，公平锁与不公平锁，而synchronized永远是公平的。

这种情况主要用于对资源的争抢（如：文件操作，同步消息发送，有状态的操作等）

ReentrantLock默认情况下为不公平锁

private ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁
private ReentrantLock lock = new ReentrantLock(true); //公平锁
    
try {
    lock.lock(); //如果被其它资源锁定，会在此等待锁释放，达到暂停的效果
 
   //操作
 
} finally {
    lock.unlock();
}

不公平锁与公平锁的区别：

　　公平情况下，操作会排一个队按顺序执行，来保证执行顺序。（会消耗更多的时间来排队）
　　不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）

场景3：如果发现该操作已经在执行，则尝试等待一段时间，等待超时则不执行（尝试等待执行）

这种其实属于场景2的改进，等待获得锁的操作有一个时间的限制，如果超时则放弃执行。
用来防止由于资源处理不当长时间占用导致死锁情况（大家都在等待资源，导致线程队列溢出）。

 1   try {
 2                     if (lock.tryLock(5, TimeUnit.SECONDS)) {  //如果已经被lock，尝试等待5s，看是否可以获得锁，如果5s后仍然无法获得锁则返回false继续执行
 3  
 4  
 5                         try {
 6  
 7  
 8                             //操作
 9  
10  
11                         } finally {
12                             lock.unlock();
13                         }
14  
15  
16                     }
17                 } catch (InterruptedException e) {
18                     e.printStackTrace(); //当前线程被中断时(interrupt)，会抛InterruptedException                 
19                 }
20

场景4：如果发现该操作已经在执行，等待执行。这时可中断正在进行的操作立刻释放锁继续下一操作。

synchronized与Lock在默认情况下是不会响应中断(interrupt)操作，会继续执行完。lockInterruptibly()提供了可中断锁来解决此问题。（场景2的另一种改进，没有超时，只能等待中断或执行完毕）

这种情况主要用于取消某些操作对资源的占用。如：（取消正在同步运行的操作，来防止不正常操作长时间占用造成的阻塞）

try {
    lock.lockInterruptibly();
    //操作
 
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

可重入概念

若一个程序或子程序可以“安全的被并行执行(Parallel computing)”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，可以再次进入并执行它（并行执行时， 个别的执行结果，都符合设计时的预期）。可重入概念是在单线程操作系统的时代提出的。

 

上面主要的介绍使用场景主要说的是在ReentrantLock中经常使用的几个方法。

　　1、lock  获得锁，如果该锁正在使用那么就会等待。

　　2、lockInterruptibly 获得锁，但是优先响应中断。在等待的过程中，会响应中断。

　　3、tryLock() 尝试获得锁，如果成功返回true.否则不等待，立即返回。

　　4、tryLock(long time,TimeUnit unit) 给定时间内的尝试获得锁。

　　5、unlock()对锁的释放。

    原文作者：平林新袖
    原文地址: https://www.cnblogs.com/plxx/p/4578523.html
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞