Java多线程并发编程中的死锁问题实例

原创 女爷i 2024-10-13 16:45 146阅读 0赞

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

以下是一个简单的Java死锁例子:

  1. // 线程1
  2. public class Thread1 extends Thread {
  3. private Object lock1 = new Object();
  4. private Object lock2 = new Object();
  5. public void run() {
  6. synchronized (lock1) { // 死锁条件1:锁A持有
  7. try {
  8. System.out.println("Thread 1 acquired lock1");
  9. // 在这里,线程2可能会等待锁1释放
  10. synchronized (lock2) { // 死锁条件2:锁B持有
  11. System.out.println("Thread 1 acquired lock2");
  12. }
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. }
  18. }
  19. // 线程2
  20. public class Thread2 extends Thread {
  21. private Object lock1 = new Object();
  22. private Object lock2 = new Object();
  23. public void run() {
  24. synchronized (lock1) { // 死锁条件1:锁A持有
  25. try {
  26. System.out.println("Thread 2 acquired lock1");
  27. // 在这里,线程1可能会等待锁2释放
  28. synchronized (lock2) { // �死锁条件2:锁B持有
  29. System.out.println("Thread 2 acquired lock2");
  30. }
  31. } catch (InterruptedException e) {
  32. e.printStackTrace();
  33. }
  34. }
  35. }
  36. }
  37. public class Main {
  38. public static void main(String[] args) {
  39. Thread1 thread1 = new Thread1();
  40. Thread2 thread2 = new Thread2();
  41. thread1.start(); // 启动线程1
  42. thread2.start(); // 启动线程2
  43. try {
  44. // 线程执行完毕后,主线程等待
  45. Thread.sleep(5000);
  46. } catch (InterruptedException e) {
  47. e.printStackTrace();
  48. }
  49. }
  50. }

在这个例子中,线程1和线程2分别持有锁A和锁B。当一个线程获得锁A并尝试获取锁B时(条件2),如果此时另一个线程已经获得了锁B并试图获取锁A(条件1),就会形成死锁。

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

发表评论

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

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

相关阅读

    相关 Java线并发编程实例

    在Java多线程并发编程中,死锁是一个常见的问题。简单来说,死锁是指两个或多个线程互相等待对方释放资源,导致它们都无法继续执行的状况。 下面是一个经典的死锁实例: ```j