Java 轮询锁使用时遇到问题解决方案
前言:
当我们遇到死锁之后,除了可以手动重启程序解决之外,还可以考虑使用顺序锁和轮询锁,这部分的内容可以参考上一篇文章Java 死锁解决方案顺序锁和轮询锁,这里就不再赘述了。然而,轮询锁在使用的过程中,如果使用不当会带来新的严重问题,所以本篇我们就来了解一下这些问题,以及相应的解决方案。
问题演示
当我们没有使用轮询锁之前,可能会出现这样的问题:
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class DeadLockByReentrantLock { public static void main(String[] args) { Lock lockA = new ReentrantLock(); // 创建锁 A Lock lockB = new ReentrantLock(); // 创建锁 B // 创建线程 1 Thread t1 = new Thread(new Runnable() { @Override public void run() { lockA.lock(); // 加锁 System.out.println("线程 1:获取到锁 A!"); try { Thread.sleep(1000); System.out.println("线程 1:等待获取 B..."); lockB.lock(); // 加锁 try { System.out.println("线程 1:获取到锁 B!"); } finally { lockA.unlock(); // 释放锁 } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockA.unlock(); // 释放锁 } } }); t1.start(); // 运行线程 // 创建线程 2 Thread t2 = new Thread(new Runnable() { @Override public void run() { lockB.lock(); // 加锁 System.out.println("线程 2:获取到锁 B!"); try { Thread.sleep(1000); System.out.println("线程 2:等待获取 A..."); lockA.lock(); // 加锁 try { System.out.println("线程 2:获取到锁 A!"); } finally { lockA.unlock(); // 释放锁 } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockB.unlock(); // 释放锁 } } }); t2.start(); // 运行线程 } }
以上代码的执行结果如下:
从上述结果可以看出,此时程序中出现了线程相互等待,并尝试获取对方(锁)资源的情况,这就是典型的死锁问题了。
简易版轮询锁
当出现死锁问题之后,我们就可以使用轮询锁来解决它了,它的实现思路是通过轮询的方式来获取多个锁,如果中途有任意一个锁获取失败,则执行回退操作,释放当前线程拥有的所有锁,等待下一次重新执行,这样就可以避免多个线程同时拥有并霸占锁资源了,从而直接解决了死锁的问题,简易版的轮询锁实现如下:
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SolveDeadLockExample2 { public static void main(String[] args) { Lock lockA = new ReentrantLock(); // 创建锁 A Lock lockB = new ReentrantLock(); // 创建锁 B // 创建线程 1(使用轮询锁) Thread t1 = new Thread(new Runnable() { @Override public void run() { // 调用轮询锁 pollingLock(lockA, lockB); } }); t1.start(); // 运行线程 // 创建线程 2 Thread t2 = new Thread(new Runnable() { @Override public void run() { lockB.lock(); // 加锁 System.out.println("线程 2:获取到锁 B!"); try { Thread.sleep(1000); System.out.println("线程 2:等待获取 A..."); lockA.lock(); // 加锁 try { System.out.println("线程 2:获取到锁 A!"); } finally { lockA.unlock(); // 释放锁 } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockB.unlock(); // 释放锁 } } }); t2.start(); // 运行线程 } /** * 轮询锁 */ private static void pollingLock(Lock lockA, Lock lockB) { // 轮询锁 while (true) { if (lockA.tryLock()) { // 尝试获取锁 System.out.println("线程 1:获取到锁 A!"); try { Thread.sleep(1000); System.out.println("线程 1:等待获取 B..."); if (lockB.tryLock()) { // 尝试获取锁 try { System.out.println("线程 1:获取到锁 B!"); } finally { lockB.unlock(); // 释放锁 System.out.println("线程 1:释放锁 B."); break; } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockA.unlock(); // 释放锁 System.out.println("线程 1:释放锁 A."); } } // 等待一秒再继续执行 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
以上代码的执行结果如下:
从上述结果可以看出,当我们在程序中使用轮询锁之后就不会出现死锁的问题了,但以上轮询锁也并不是完美无缺的,下面我们来看看这个轮询锁会有什么样的问题?
问题1:死循环
以上简易版的轮询锁,如果遇到有一个线程一直霸占或者长时间霸占锁资源的情况,就会导致这个轮询锁进入死循环的状态,它会尝试一直获取锁资源,这样就会造成新的问题,带来不必要的性能开销,具体示例如下。
反例
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SolveDeadLockExample { public static void main(String[] args) { Lock lockA = new ReentrantLock(); // 创建锁 A Lock lockB = new ReentrantLock(); // 创建锁 B // 创建线程 1(使用轮询锁) Thread t1 = new Thread(new Runnable() { @Override public void run() { // 调用轮询锁 pollingLock(lockA, lockB); } }); t1.start(); // 运行线程 // 创建线程 2 Thread t2 = new Thread(new Runnable() { @Override public void run() { lockB.lock(); // 加锁 System.out.println("线程 2:获取到锁 B!"); try { Thread.sleep(1000); System.out.println("线程 2:等待获取 A..."); lockA.lock(); // 加锁 try { System.out.println("线程 2:获取到锁 A!"); } finally { lockA.unlock(); // 释放锁 } } catch (InterruptedException e) { e.printStackTrace(); } finally { // 如果此处代码未执行,线程 2 一直未释放锁资源 // lockB.unlock(); } } }); t2.start(); // 运行线程 } /** * 轮询锁 */ public static void pollingLock(Lock lockA, Lock lockB) { while (true) { if (lockA.tryLock()) { // 尝试获取锁 System.out.println("线程 1:获取到锁 A!"); try { Thread.sleep(1000); System.out.println("线程 1:等待获取 B..."); if (lockB.tryLock()) { // 尝试获取锁 try { System.out.println("线程 1:获取到锁 B!"); } finally { lockB.unlock(); // 释放锁 System.out.println("线程 1:释放锁 B."); break; } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockA.unlock(); // 释放锁 System.out.println("线程 1:释放锁 A."); } } // 等待一秒再继续执行 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
以上代码的执行结果如下:
从上述结果可以看出,线程 1 轮询锁进入了死循环的状态。
优化版
针对以上死循环的情况,我们可以改进的思路有以下两种:
- 添加最大次数限制:如果经过了 n 次尝试获取锁之后,还未获取到锁,则认为获取锁失败,执行失败策略之后终止轮询(失败策略可以是记录日志或其他操作);
- 添加最大时长限制:如果经过了 n 秒尝试获取锁之后,还未获取到锁,则认为获取锁失败,执行失败策略之后终止轮询。
以上策略任选其一就可以解决死循环的问题,出于实现成本的考虑,我们可以采用轮询最大次数的方式来改进轮询锁,
具体实现代码如下:
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SolveDeadLockExample { public static void main(String[] args) { Lock lockA = new ReentrantLock(); // 创建锁 A Lock lockB = new ReentrantLock(); // 创建锁 B // 创建线程 1(使用轮询锁) Thread t1 = new Thread(new Runnable() { @Override public void run() { // 调用轮询锁 pollingLock(lockA, lockB, 3); } }); t1.start(); // 运行线程 // 创建线程 2 Thread t2 = new Thread(new Runnable() { @Override public void run() { lockB.lock(); // 加锁 System.out.println("线程 2:获取到锁 B!"); try { Thread.sleep(1000); System.out.println("线程 2:等待获取 A..."); lockA.lock(); // 加锁 try { System.out.println("线程 2:获取到锁 A!"); } finally { lockA.unlock(); // 释放锁 } } catch (InterruptedException e) { e.printStackTrace(); } finally { // 线程 2 忘记释放锁资源 // lockB.unlock(); // 释放锁 } } }); t2.start(); // 运行线程 } /** * 轮询锁 * * maxCount:最大轮询次数 */ public static void pollingLock(Lock lockA, Lock lockB, int maxCount) { // 轮询次数计数器 int count = 0; while (true) { if (lockA.tryLock()) { // 尝试获取锁 System.out.println("线程 1:获取到锁 A!"); try { Thread.sleep(1000); System.out.println("线程 1:等待获取 B..."); if (lockB.tryLock()) { // 尝试获取锁 try { System.out.println("线程 1:获取到锁 B!"); } finally { lockB.unlock(); // 释放锁 System.out.println("线程 1:释放锁 B."); break; } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockA.unlock(); // 释放锁 System.out.println("线程 1:释放锁 A."); } } // 判断是否已经超过最大次数限制 if (count++ > maxCount) { // 终止循环 System.out.println("轮询锁获取失败,记录日志或执行其他失败策略"); return; } // 等待一秒再继续尝试获取锁 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
以上代码的执行结果如下:
从以上结果可以看出,当我们改进之后,轮询锁就不会出现死循环的问题了,它会尝试一定次数之后终止执行。
问题2:线程饿死
我们以上的轮询锁的轮询等待时间是固定时间,如下代码所示:
// 等待 1s 再尝试获取(轮询)锁 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
这样在特殊情况下会造成线程饿死的问题,也就是轮询锁一直获取不到锁的问题,比如以下示例。
反例
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SolveDeadLockExample { public static void main(String[] args) { Lock lockA = new ReentrantLock(); // 创建锁 A Lock lockB = new ReentrantLock(); // 创建锁 B // 创建线程 1(使用轮询锁) Thread t1 = new Thread(new Runnable() { @Override public void run() { // 调用轮询锁 pollingLock(lockA, lockB, 3); } }); t1.start(); // 运行线程 // 创建线程 2 Thread t2 = new Thread(new Runnable() { @Override public void run() { while (true) { lockB.lock(); // 加锁 System.out.println("线程 2:获取到锁 B!"); try { System.out.println("线程 2:等待获取 A..."); lockA.lock(); // 加锁 try { System.out.println("线程 2:获取到锁 A!"); } finally { lockA.unlock(); // 释放锁 } } finally { lockB.unlock(); // 释放锁 } // 等待一秒之后继续执行 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }); t2.start(); // 运行线程 } /** * 轮询锁 */ public static void pollingLock(Lock lockA, Lock lockB, int maxCount) { // 循环次数计数器 int count = 0; while (true) { if (lockA.tryLock()) { // 尝试获取锁 System.out.println("线程 1:获取到锁 A!"); try { Thread.sleep(100); // 等待 0.1s(获取锁需要的时间) System.out.println("线程 1:等待获取 B..."); if (lockB.tryLock()) { // 尝试获取锁 try { System.out.println("线程 1:获取到锁 B!"); } finally { lockB.unlock(); // 释放锁 System.out.println("线程 1:释放锁 B."); break; } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockA.unlock(); // 释放锁 System.out.println("线程 1:释放锁 A."); } } // 判断是否已经超过最大次数限制 if (count++ > maxCount) { // 终止循环 System.out.println("轮询锁获取失败,记录日志或执行其他失败策略"); return; } // 等待一秒再继续尝试获取锁 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
以上代码的执行结果如下:
从上述结果可以看出,线程 1(轮询锁)一直未成功获取到锁,造成这种结果的原因是:线程 1 每次轮询的等待时间为固定的 1s,而线程 2 也是相同的频率,每 1s 获取一次锁,这样就会导致线程 2 会一直先成功获取到锁,而线程 1 则会一直处于“饿死”的情况,执行流程如下图所示:
优化版
接下来,我们可以将轮询锁的固定等待时间,改进为固定时间 + 随机时间的方式,这样就可以避免因为获取锁的频率一致,而造成轮询锁“饿死”的问题了,具体实现代码如下:
import java.util.Random; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SolveDeadLockExample { private static Random rdm = new Random(); public static void main(String[] args) { Lock lockA = new ReentrantLock(); // 创建锁 A Lock lockB = new ReentrantLock(); // 创建锁 B // 创建线程 1(使用轮询锁) Thread t1 = new Thread(new Runnable() { @Override public void run() { // 调用轮询锁 pollingLock(lockA, lockB, 3); } }); t1.start(); // 运行线程 // 创建线程 2 Thread t2 = new Thread(new Runnable() { @Override public void run() { while (true) { lockB.lock(); // 加锁 System.out.println("线程 2:获取到锁 B!"); try { System.out.println("线程 2:等待获取 A..."); lockA.lock(); // 加锁 try { System.out.println("线程 2:获取到锁 A!"); } finally { lockA.unlock(); // 释放锁 } } finally { lockB.unlock(); // 释放锁 } // 等待一秒之后继续执行 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }); t2.start(); // 运行线程 } /** * 轮询锁 */ public static void pollingLock(Lock lockA, Lock lockB, int maxCount) { // 循环次数计数器 int count = 0; while (true) { if (lockA.tryLock()) { // 尝试获取锁 System.out.println("线程 1:获取到锁 A!"); try { Thread.sleep(100); // 等待 0.1s(获取锁需要的时间) System.out.println("线程 1:等待获取 B..."); if (lockB.tryLock()) { // 尝试获取锁 try { System.out.println("线程 1:获取到锁 B!"); } finally { lockB.unlock(); // 释放锁 System.out.println("线程 1:释放锁 B."); break; } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lockA.unlock(); // 释放锁 System.out.println("线程 1:释放锁 A."); } } // 判断是否已经超过最大次数限制 if (count++ > maxCount) { // 终止循环 System.out.println("轮询锁获取失败,记录日志或执行其他失败策略"); return; } // 等待一定时间(固定时间 + 随机时间)之后再继续尝试获取锁 try { Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定时间 + 随机时间 } catch (InterruptedException e) { e.printStackTrace(); } } } }
以上代码的执行结果如下:
从上述结果可以看出,线程 1(轮询锁)加入随机等待时间之后就不会出现线程饿死的问题了。
总结
本文我们介绍了轮询锁的用途,用于解决死锁问题,但简易版的轮询锁在某些情况下会造成死循环和线程饿死的问题,因此我们对轮询锁进行了优化,给轮询锁加入了最大轮询次数,以及随机轮询等待时间,这样就可以解决因为引入轮询锁而造成的新问题了,这样就可以愉快的使用它来解决死锁的问题了。
到此这篇关于Java 轮询锁使用时遇到问题解决方案的文章就介绍到这了,更多相关Java 轮询锁内容请搜索猪先飞以前的文章或继续浏览下面的相关文章希望大家以后多多支持猪先飞!
原文出处:https://juejin.cn/post/7002391952876372004
相关文章
- 这篇文章主要介绍了如何利用java语言实现经典《复杂迷宫》游戏,文中采用了swing技术进行了界面化处理,感兴趣的小伙伴可以动手试一试...2022-02-01
- 409错误是什么?http 409错误怎么解决呢?不少站长在遇到这个错误代码之后都一筹莫展,本次一聚教程网为大家带来了详细的说明,快来看看吧。 409错误是什么: HTTP 40...2017-01-22
- http 405错误是什么?http 405错误怎么解决?相信很多站长都在找这两个问题的答案,本次小编为大家带来了详细的教程,快来看看吧。 405错误是什么: HTTP 405错误是H...2017-01-22
java 运行报错has been compiled by a more recent version of the Java Runtime
java 运行报错has been compiled by a more recent version of the Java Runtime (class file version 54.0)...2021-04-01- 这篇文章主要介绍了在java中获取List集合中最大的日期时间操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-08-15
- 403错误是HTTP状态码的一种,属于“请示错误”,表示服务器拒绝请求。如果在搜索引擎尝试抓取您网站上的有效网页时显示此状态代码,那么,这可能是您的服务器或主机拒绝搜索...2017-01-22
- 412错误是什么?412错误怎么解决?本次一聚教程网将为大家带来详细的介绍,帮助大家全面了解412错误的意思以及解决412错误的方法。 412错误是什么: HTTP 412错误,(Precond...2017-01-22
- 今天用CPAN安装Term::ReadLine,报了个这样的错误 Going to read /root/.cpan/sources/modules/03modlist.data.gz Can't locate object method "data" via package "C...2016-11-25
- 407错误是什么?407错误怎么解决?不少站长都遇到过407错误,下面小编将告诉大家如何处理407错误。 407错误是什么: HTTP 407错误是HTTP协议状态码的一种,表示需要代...2017-01-22
- HTTP 406错误是HTTP协议状态码的一种,表示无法使用请求的内容特性来响应请求的网页。一般是指客户端浏览器不接受所请求页面的 MIME 类型。 而MIME类型是在把输出...2017-01-22
- 410错误是HTTP协议状态码的一种,本次一聚教程网将为大家详细介绍HTTP 410错误是什么,以及410错误的解决办法。 410错误是什么: HTTP 410错误是HTTP协议状态码的...2017-01-22
- 这篇文章主要介绍了教你怎么用Java获取国家法定节假日,文中有非常详细的代码示例,对正在学习java的小伙伴们有非常好的帮助,需要的朋友可以参考下...2021-04-23
- 这篇文章主要介绍了Java如何发起http请求的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧...2021-03-31
- 每当遇到http错误代码为400,代表客户端发起的请求不符合服务器对请求的某些限制,或者请求本身存在一定的错误,那么HTTP 400错误怎么解决呢?请看下文介绍。 目前400错...2017-01-22
- 说起C#和Java这两门语言(语法,数据类型 等),个人以为,大概有90%以上的相似,甚至可以认为几乎一样。但是在工作中,我也发现了一些细微的差别...2020-06-25
- 这篇文章主要介绍了解决Java处理HTTP请求超时的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2021-03-29
- 这篇文章主要介绍了java 判断两个时间段是否重叠的案例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-08-15
- 这篇文章主要介绍了超简洁java实现双色球若干注随机号码生成(实例代码),本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下...2021-04-02
- 这篇文章主要介绍了Java生成随机姓名、性别和年龄的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧...2020-10-01
java 画pdf用itext调整表格宽度、自定义各个列宽的方法
这篇文章主要介绍了java 画pdf用itext调整表格宽度、自定义各个列宽的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2021-01-31