[Java concurrent programming] 9: deadlock (including code), java concurrency

[Java concurrent programming] 9: deadlock (including code), java concurrency

A deadlock may occur when the thread needs to hold multiple locks at the same time. Consider the following situations:

Thread A currently holds the lock1 lock and thread B currently holds the lock2 lock. Next, when thread A still holds lock1, it tries to get lock2 because thread B is holding lock2, so thread A will block waiting for thread B to release lock2. If thread B tries to obtain lock1 when holding lock2 at this time, because thread A is holding lock1, thread B will block waiting for A to release lock1. Both of them are waiting for the release of the lock held by the other party, but they have not released the lock held by themselves, then the two will continue to block. This situation is called a deadlock.

The following is an example of a deadlock between two threads:

[Java]View plaincopy

1. Public class Deadlock extends Object {
2. Private String objID;
4. Public Deadlock (String id ){
5. ObjID = id;
6. }
8. Public synchronized void checkOther (Deadlock other ){
9. Print ("entering checkOther ()");
10. Try {Thread. sleep (2000 );}
11. Catch (InterruptedException x ){}
12. Print ("in checkOther ()-about to" + "invoke 'other. action ()'");
14. // Call the action Method of the other object. Because this method is a synchronous method, it will try to obtain the object lock of the other object.
15. Other. action ();
16. Print ("leaving checkOther ()");
17. }
19. Public synchronized void action (){
20. Print ("entering action ()");
21. Try {Thread. sleep (500 );}
22. Catch (InterruptedException x ){}
23. Print ("leaving action ()");
24. }
26. Public void print (String msg ){
27. ThreadPrint ("objID =" + objID + "-" + msg );
28. }
30. Public static void threadPrint (String msg ){
31. String threadName = Thread. currentThread (). getName ();
32. System. out. println (threadName + ":" + msg );
33. }
35. Public static void main (String [] args ){
36. Final Deadlock obj1 = new Deadlock ("obj1 ");
37. Final Deadlock obj2 = new Deadlock ("obj2 ");
39. Runnable runA = new Runnable (){
40. Public void run (){
41. Obj1.checkOther (obj2 );
42. }
43. };
45. Thread threadA = new Thread (runA, "threadA ");
46. ThreadA. start ();
48. Try {Thread. sleep (200 );}
49. Catch (InterruptedException x ){}
51. Runnable runB = new Runnable (){
52. Public void run (){
53. Obj2.checkOther (obj1 );
54. }
55. };
57. Thread threadB = new Thread (runB, "threadB ");
58. ThreadB. start ();
60. Try {Thread. sleep (5000 );}
61. Catch (InterruptedException x ){}
63. ThreadPrint ("finished sleeping ");
65. ThreadPrint ("about to interrupt () threadA ");
66. ThreadA. interrupt ();
68. Try {Thread. sleep (1000 );}
69. Catch (InterruptedException x ){}
71. ThreadPrint ("about to interrupt () threadB ");
72. ThreadB. interrupt ();
74. Try {Thread. sleep (1000 );}
75. Catch (InterruptedException x ){}
77. ThreadPrint ("did that break the deadlock? ");
78. }
79. }

The running result is as follows:

As shown in the result. action (), because both threads are trying to obtain the lock of the other side, but neither of them has released its own lock, a deadlock occurs and two threads are trying to interrupt in the main thread, but none.

Most of the Code is not prone to deadlocks. Deadlocks may hide for a long time in the code, waiting for uncommon conditions to occur, but even if it is a small probability, once a deadlock occurs, this can cause devastating damage. It is difficult to avoid deadlocks. The following principles help avoid deadlocks:

1. Only hold the lock within the shortest time required. Use the synchronous statement block instead of the entire synchronization method;

2. Try to write code that requires multiple locks at different times. If unavoidable, make sure that the thread holds the second lock for as short as possible;

3. Create and use a large lock to replace several small locks, and use the lock for mutual exclusion instead of the object-Level Lock of a single object;