Java怎么防止死锁 java解决死锁

死锁在多线程的情况下，在竞争竞态条件与临界区（http://cuisuqiang.iteye.com/blog/2020152）出现时，会出现数据不同步情况， 而为了避免这种情况，之前也说了：界区实现方法有两种，一种是用synchronized，一种是用Lock显式锁实现。

而如果不恰当的使用了锁，且出现同时要锁多个对象时，会出现死锁情况，如下：

1. package
2. import
3. /**
4.  * 崔素强
5.  * @author [e-mail]
6.  */
7. public class
8. public static String obj1 = "obj1";  
9. public static String obj2 = "obj2";  
10. public static void
11. new
12. new
13. new
14. new
15.     }  
16. }  
17. class LockA implements
18. public void
19. try
20. new Date().toString() + " LockA 开始执行");  
21. while(true){  
22. synchronized
23. new Date().toString() + " LockA 锁住 obj1");  
24. 3000); // 此处等待是给B能锁住机会
25. synchronized
26. new Date().toString() + " LockA 锁住 obj2");  
27. 60 * 1000); // 为测试，占用了就不放
28.                     }  
29.                 }  
30.             }  
31. catch
32.             e.printStackTrace();  
33.         }  
34.     }  
35. }  
36. class LockB implements
37. public void
38. try
39. new Date().toString() + " LockB 开始执行");  
40. while(true){  
41. synchronized
42. new Date().toString() + " LockB 锁住 obj2");  
43. 3000); // 此处等待是给A能锁住机会
44. synchronized
45. new Date().toString() + " LockB 锁住 obj1");  
46. 60 * 1000); // 为测试，占用了就不放
47.                     }  
48.                 }  
49.             }  
50. catch
51.             e.printStackTrace();  
52.         }  
53.     }  
54. }

 

看打印：

1. Mon Mar 31 10:52:38 CST 2014
2. Mon Mar 31 10:52:38 CST 2014
3. Mon Mar 31 10:52:38 CST 2014
4. Mon Mar 31 10:52:38 CST 2014

 

A锁住了B需要的，B锁住了A需要的，此时死锁产生。

 

为了解决这个问题，我们不使用显示的去锁，我们用信号量（http://cuisuqiang.iteye.com/blog/2020146）去控制。

信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。

对于无法成功获取的情况，一般就是重复尝试，或指定尝试的次数，也可以马上退出。

来看下如下代码：

1. package
2. import
3. import
4. import
5. /**
6.  * 崔素强
7.  * @author [e-mail]
8.  */
9. public class
10. public static String obj1 = "obj1";  
11. public static final Semaphore a1 = new Semaphore(1);  
12. public static String obj2 = "obj2";  
13. public static final Semaphore a2 = new Semaphore(1);  
14.   
15. public static void
16. new
17. new
18. new
19. new
20.     }  
21. }  
22. class LockAa implements
23. public void
24. try
25. new Date().toString() + " LockA 开始执行");  
26. while (true) {  
27. if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {  
28. new Date().toString() + " LockA 锁住 obj1");  
29. if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {  
30. new Date().toString() + " LockA 锁住 obj2");  
31. 60 * 1000); // do something
32. else{  
33. new Date().toString() + "LockA 锁 obj2 失败");  
34.                     }  
35. else{  
36. new Date().toString() + "LockA 锁 obj1 失败");  
37.                 }  
38. // 释放
39.                 UnLockTest.a2.release();  
40. 1000); // 马上进行尝试，现实情况下do something是不确定的
41.             }  
42. catch
43.             e.printStackTrace();  
44.         }  
45.     }  
46. }  
47. class LockBb implements
48. public void
49. try
50. new Date().toString() + " LockB 开始执行");  
51. while (true) {  
52. if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {  
53. new Date().toString() + " LockB 锁住 obj2");  
54. if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {  
55. new Date().toString() + " LockB 锁住 obj1");  
56. 60 * 1000); // do something
57. else{  
58. new Date().toString() + "LockB 锁 obj1 失败");  
59.                     }  
60. else{  
61. new Date().toString() + "LockB 锁 obj2 失败");  
62.                 }  
63. // 释放
64.                 UnLockTest.a2.release();  
65. 10 * 1000); // 这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁
66.             }  
67. catch
68.             e.printStackTrace();  
69.         }  
70.     }  
71. }

 

看打印情况：

1. Mon Mar 31 10:57:07 CST 2014
2. Mon Mar 31 10:57:07 CST 2014
3. Mon Mar 31 10:57:07 CST 2014
4. Mon Mar 31 10:57:07 CST 2014
5. Mon Mar 31 10:57:08
6. Mon Mar 31 10:57:08
7. Mon Mar 31 10:57:09 CST 2014
8. Mon Mar 31 10:57:09 CST 2014

 

第一次两个线程获取信号量时都会失败，因为失败后B等待时间长，所以A再次尝试时会成功。

 

实际中，你执行任务内容不同，所需时间是不同的。另外不同的线程，对于获取信号量失败的处理也可能是不同的。所以，虽然不会产生死锁，但是你要根据实际情况，来编写获取失败后的处理机制。