线程死锁

线程死锁概念

两个线程A/B，A线程掌握着实例1的锁，要访问实例2的synchronized方法，但是实例2的锁被B所掌握着，然而B这时候又要访问实例1的synchronized方法，两个线程一直等着对方释放实例1/实例2的锁，造成程序无法进行下去，这种现象称为线程访问的死锁

代码示例

 1 package test;
 2 
 3 public class ThreadDeadLock {
 4 
 5     public static void main(String[] args) {
 6         Object a = new Object();
 7         Object b = new Object();
 8 
 9         MyThread1 t1 = new MyThread1(a, b);
10         MyThread2 t2 = new MyThread2(a, b);
11 
12         t1.start();
13         t2.start();
14 
15     }
16 
17 }
18 
19 class MyThread1 extends Thread {
20     private Object a;
21     private Object b;
22 
23     public MyThread1(Object a, Object b) {
24         this.a = a;
25         this.b = b;
26     }
27 
28     @Override
29     public void run() {
30         synchronized (a) {
31             try {
32                 Thread.sleep(2000);
33             } catch (Exception e) {
34                 e.printStackTrace();
35             }
36 
37             synchronized (b) {
38 
39             }
40         }
41     }
42 }
43 
44 class MyThread2 extends Thread {
45     private Object a;
46     private Object b;
47 
48     public MyThread2(Object a, Object b) {
49         this.a = a;
50         this.b = b;
51     }
52 
53     @Override
54     public void run() {
55 
56         synchronized (b) {
57 
58             try {
59                 Thread.sleep(2000);
60             } catch (Exception e) {
61                 e.printStackTrace();
62             }
63 
64             synchronized (a) {
65 
66             }
67         }
68 
69     }
70 }