1. public class DeadLockTest {
   
2. 
   
3.     public static void main(String[] args) {
   
4.         Thread t1 = new Thread(new Test(true));
   
5.         Thread t2 = new Thread(new Test(false));
   
6.         t1.start();
   
7.         t2.start();
   
8.     }
   
9. }
   
10. class MyLock
    
11. {
    
12.          //static MyLock lock1=new MyLock();
    
13.          //static MyLock lock2=new MyLock();
    
14. 
    
15. }
    
16. 
    
17. class Test implements Runnable {
    
18. 
    
19.     MyLock lock1=new MyLock();//加static就会死锁
    
20.     MyLock lock2=new MyLock();//加static就会死锁
    
21. 
    
22.     private boolean flag;
    
23.     Object obj1 = new Object();
    
24.     Object obj2 = new Object();
    
25. 
    
26.     public Test(boolean flag) {
    
27.         this.flag = flag;
    
28.     }
    
29. 
    
30.     public void run() {
    
31.         if (flag) {
    
32.             while (true) {
    
33.                 synchronized (lock1) {
    
34.                     System.out.println("if lock1");
    
35.                     synchronized (lock2) {
    
36.                         System.out.println("if lock2");
    
37.                     }
    
38.                 }
    
39.             }
    
40.         } else {
    
41.             while (true) {
    
42.                 synchronized (lock2) {
    
43.                     System.out.println("else lock2");
    
44.                     synchronized (lock1) {
    
45.                         System.out.println("else lock1");
    
46.                     }
    
47.                 }
    
48.             }
    
49.         }
    
50.     }
    
51. }

复制代码

我想问一下以上程序为什么在注释处加static才会产生死锁，不加static为什么不会产生死锁现象？

因为你在主线程中创建了两个Test  没有static的话，相当于有4个锁，两个循环中的lock1并不是一个类，每个同步块一个不同的锁，就不会产生死锁。
如果加上static 两个lock在所有Test中只存在两个，这样同步块中嵌套了另一个锁的同步块，就会死锁。

在开发时是为了避免死锁，你这样是做什么用的？明确需求，分析问题。。。。。。