Java并发编程:死锁示例解析

原创 左手的ㄟ右手 2024-09-30 07:27 242阅读 0赞

死锁是多线程编程中的一种严重问题,当两个或更多的线程在执行过程中因争夺资源而造成的一种互相等待的现象称为死锁。

下面是一个经典的死锁示例:

  1. // 定义资源
  2. class Resource {
  3. private int count;
  4. public Resource(int count) {
  5. this.count = count;
  6. }
  7. // 获取资源,计数减1
  8. public synchronized void acquire() {
  9. if (count == 0) throw new RuntimeException("Resource exhausted");
  10. count--;
  11. }
  12. // 释放资源,计数加1
  13. public synchronized void release() {
  14. count++;
  15. // 检查是否有循环等待(死锁)
  16. if (count > resourceCount) throw new RuntimeException("Deadlock detected");
  17. }
  18. // 获取当前资源总数
  19. public int getCount() {
  20. return count;
  21. }
  22. private int resourceCount; // 全部资源数量
  23. }
  24. // 定义线程
  25. class ThreadA extends Thread {
  26. Resource resource1 = new Resource(5);
  27. ThreadA() {
  28. start();
  29. }
  30. @Override
  31. public void run() {
  32. resource1.acquire(); // 获取第一个资源
  33. try {
  34. Thread.sleep(1000); // 暂停执行,模拟等待资源
  35. } catch (InterruptedException e) {
  36. e.printStackTrace();
  37. }
  38. resource1.release(); // 释放第一个资源
  39. }
  40. }
  41. class ThreadB extends Thread {
  42. Resource resource2 = new Resource(5);
  43. ThreadB() {
  44. start();
  45. }
  46. @Override
  47. public void run() {
  48. resource2.acquire(); // 获取第二个资源
  49. try {
  50. Thread.sleep(1000); // 暂停执行,模拟等待资源
  51. } catch (InterruptedException e) {
  52. e.printStackTrace();
  53. }
  54. resource2.release(); // 释放第二个资源
  55. }
  56. }
  57. public class Main {
  58. public static void main(String[] args) {
  59. Resource resourceCount = 5; // 全部资源数量
  60. ThreadA threadA = new ThreadA();
  61. ThreadB threadB = new ThreadB();
  62. threadA.start();
  63. threadB.start();
  64. try {
  65. threadA.join();
  66. threadB.join();
  67. } catch (InterruptedException e) {
  68. e.printStackTrace();
  69. }
  70. // 检查是否存在循环等待(死锁)
  71. if (resourceCount != resource1.getCount() + resource2.getCount()) {
  72. System.out.println("Deadlock detected");
  73. } else {
  74. System.out.println("No deadlock detected");
  75. }
  76. }
  77. }

在这个示例中,两个线程(ThreadA和ThreadB)分别获取了资源1和资源2。线程A在获取资源后休眠一段时间,然后释放资源。同理,线程B也是这样操作的。

如果线程等待时间过长或者出现其他情况导致循环等待(死锁),则程序会输出”Deadlock detected”。否则,输出”No deadlock detected”。

文章版权声明:注明蒲公英云原创文章,转载或复制请以超链接形式并注明出处。

发表评论

表情:
评论列表 (有 0 条评论,242人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Java并发编程实例

    在Java并发编程中,死锁是一个常见的问题。死锁是指两个或更多的进程(线程)因争夺资源而造成的一种互相等待的现象,若无外力干涉它们将无法继续执行。 以下是一例简单的Java死

    相关 Java并发编程现象

    在Java的并发编程中,死锁是一种严重的状态,会导致资源无法继续使用。 死锁的现象通常有以下特征: 1. **互斥条件**:两个或多个线程正在访问并可能修改同一资源。 2

    相关 Java并发编程案例

    在Java并发编程中,死锁是一个非常关键和常见的问题。简单来说,死锁是指两个或多个并发进程,在执行过程中因争夺资源而造成的一种互相等待的现象,且每个进程都处于等待状态,无法继续

    相关 Java并发编程现象

    在Java并发编程中,死锁是一个非常关键且可能导致程序僵化的问题。 **什么是死锁?** 死锁是指两个或更多的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外

    相关 并发编程

    [转载][Link 1] 前言 在 Java 的并发编程中,有一个问题需要特别注意,那就是死锁,如果发生了死锁,基本就是重启,而重启将会丢失运行中的数据。所以,了解死锁