1. public class TestDeadLock implements Runnable{
   
2.     public int flag = 2;
   
3.     static Object o1 = new Object();
   
4.     static Object o2 = new Object();
   
5.    
   
6.     public void run(){
   
7.         if(flag == 1){
   
8.             synchronized(o1){
   
9.                 System.out.println("锁住o1");   
   
10.                 try {
    
11.                     Thread.sleep(5000);
    
12.                 }catch(Exception e){}
    
13.             }
    
14.             
    
15.             synchronized(o2){
    
16.                 System.out.println("1");
    
17.             }
    
18.         }
    
19.         //疑问：无法死锁
    
20.         if(flag == 0){
    
21.             synchronized(o2){
    
22.                 System.out.println("锁住o2");
    
23.                 try {
    
24.                     Thread.sleep(5000);
    
25.                 }catch(Exception e){}
    
26.             }
    
27.             
    
28.             synchronized(o1){
    
29.                 System.out.println("2");
    
30.             }
    
31.         }
    
32.     }
    
33.    
    
34.     public static void main(String[] args){
    
35.         TestDeadLock td1 = new TestDeadLock();
    
36.         TestDeadLock td2 = new TestDeadLock();
    
37.         td1.flag = 1;
    
38.         td2.flag = 0;
    
39.         Thread t1 = new Thread(td1);
    
40.         Thread t2 = new Thread(td2);
    
41.         t1.start();
    
42.         t2.start();
    
43.     }
    
44. }

复制代码

我的理解是，两个线程分别锁住两个对象，再等待获取另一个对象的线程锁，那么此时会形成死锁，但是实际是没有死锁，还能正确运行到结束。

public class TestDeadLock implements Runnable{
    public String name;
    static Object os = new Object();
    public TestDeadLock(String name){
        this.name=name;
    }
   
   
    public void run(){
         synchronized(os){
                System.out.println("锁住线程"+name);   
                try {
                    Thread.sleep(5000);
                }catch(Exception e){}
            
            
         
        }
      
    }
   
    public static void main(String[] args){
        TestDeadLock td1 = new TestDeadLock("A");
        TestDeadLock td2 = new TestDeadLock("B");
     
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();
    }
}
注意：使用同步代码块格式
synchronized(同步对象){
  需要同步的代码块
}

1. 
   
2. <BLOCKQUOTE>
   
3. <P> </P>
   
4. <P>你拿的根本就不是同一锁，当然不会出现死锁，对你的代码修改如下：</P>

复制代码

1. 01.public class TestDeadLock implements Runnable{
   
2. 
   
3. 02. public int flag = 2;
   
4. 
   
5. 03. static Object o1 = new Object();
   
6. 
   
7. 04. static Object o2 = new Object();
   
8. 
   
9. 05.
   
10. 
    
11. 06. public void run(){
    
12. 
    
13. 07. if(flag == 1){
    
14. 
    
15. 08. synchronized(o1){
    
16. 
    
17. 09. System.out.println("锁住o1");
    
18. 
    
19. 10. try {
    
20. 
    
21. 11. Thread.sleep(5000);
    
22. 
    
23. 12. }catch(Exception e){}
    
24. 
    
25. 13. }
    
26. 
    
27. 14.
    
28. 
    
29. 15. synchronized(o2){
    
30. 
    
31. 16. System.out.println("1");
    
32. 
    
33. 17. }
    
34. 
    
35. 18. }
    
36. 
    
37. 19. //疑问：无法死锁
    
38. 
    
39. 20.
    
40. public synchronized void run2()
    
41. {
    
42. if(flag == 0){
    
43. 
    
44. 21. synchronized(o1){
    
45. 
    
46. 22. System.out.println("锁住o2");
    
47. 
    
48. 23. try {
    
49. 
    
50. 24. Thread.sleep(5000);
    
51. 
    
52. 25. }catch(Exception e){}
    
53. 
    
54. 26. }
    
55. 
    
56. 27.
    
57. 
    
58. 28. synchronized(o1){
    
59. 
    
60. 29. System.out.println("2");
    
61. 
    
62. 30. }
    
63. 
    
64. 31. }
    
65. 
    
66. 32. }
    
67. }
    
68. 
    
69. 34. public static void main(String[] args){
    
70. 
    
71. 35. TestDeadLock td1 = new TestDeadLock();
    
72. 
    
73. 36. TestDeadLock td2 = new TestDeadLock();
    
74. 
    
75. 37. td1.flag = 1;
    
76. 
    
77. 38. td2.flag = 0;
    
78. 
    
79. 39. Thread t1 = new Thread(td1);
    
80. 
    
81. 40. Thread t2 = new Thread(td2);
    
82. 
    
83. 41. t1.start();
    
84. 
    
85. 42. t2.start();
    
86. 
    
87. 43. }
    
88. 
    
89. 44.}
    

复制代码

楼主你的代码是这样走的，flat == 1中的代码，锁住o1时，继续往下执行去尝试锁住o2，这个时候flat == 0中的代码，锁o2的代码可能已经执行完了，所以flat == 1中可以顺利的锁住o2，flat == 0中也是一样，当它去锁o1时锁也应经放开了，
你这个代码修改一点点就行了，思路是让flat == 1中锁住o1等待锁住o2，flat == 0中锁住o2等待锁住o1，让他们俩一门报一个锁并等待另外一个锁，他俩都不放开，所以死锁了
具体代码：

1. public class TestDeadLock implements Runnable{
   
2.     public int flag = 2;
   
3.     static Object o1 = new Object();
   
4.     static Object o2 = new Object();
   
5.    
   
6.     public void run(){
   
7.         if(flag == 1){
   
8.             synchronized(o1){
   
9.                 System.out.println("锁住o1");                  
   
10.                 try {
    
11.                     Thread.sleep(5000);
    
12. //锁o2的代码放在已经锁住o1的里面
    
13. //睡眠5秒确保另外一个线程已经锁住了o2
    
14.                     synchronized(o2){
    
15.                         System.out.println("1");
    
16.                     }
    
17.                 }catch(Exception e){}
    
18.             }
    
19.             
    
20.            
    
21.         }
    
22.         //疑问：无法死锁
    
23.         if(flag == 0){
    
24.             synchronized(o2){
    
25.                 System.out.println("锁住o2");               
    
26.                 try {
    
27. //锁o1的代码放在已经锁住o2的里面
    
28. //睡眠5秒确保另外一个线程已经锁住了o1
    
29.                     Thread.sleep(5000);
    
30.                         synchronized(o1){
    
31.                     System.out.println("2");
    
32.                 }
    
33.                 }catch(Exception e){}
    
34.             }         
    
35.         }
    
36.     }
    
37.    
    
38.     public static void main(String[] args){
    
39.         TestDeadLock td1 = new TestDeadLock();
    
40.         TestDeadLock td2 = new TestDeadLock();
    
41.         td1.flag = 1;
    
42.         td2.flag = 0;
    
43.         Thread t1 = new Thread(td1);
    
44.         Thread t2 = new Thread(td2);
    
45.         t1.start();
    
46.         t2.start();
    
47.     }
    
48. }
    

复制代码

锁住o1
锁住o2

他们俩都抱住一个锁，等待另外一个锁，程序停住了。。。。。ok,楼主复制回去看看，只是把锁资源的代码改改位置就可以了

一个拿到o1对象准备去拿o2，另一个拿到o2对象准备去拿o1;
你写的代码意思是:
第一个拿到o1后,锁住o1,sleep 5秒,释放o1,去取o2
第二个拿到o2后,锁住o2,sleep 5秒,释放o2,去取o1;
那么,不管是谁睡5秒后,都会释放掉自己手里的锁的,
改成如下代码:
public class TestDeadLock implements Runnable {
        public int flag = 2;
        static Object o1 = new Object();
        static Object o2 = new Object();

        public void run() {
                if (flag == 1) {
                        synchronized (o1) {
                                System.out.println("锁住o1");
                                // Thread.currentThread().interrupt();         //如果任意一个线程打断的话,就会运行到结束
                                synchronized (o2) {                                //不用加sleep(5000)
                                        System.out.println("1");   //这样的代码才是锁住o1,想要获得o2
                                }                        }

                }
                // 疑问：无法死锁
                if (flag == 0) {
                        synchronized (o2) {
                                System.out.println("锁住o2");
                                synchronized (o1) {                  //这样的代码才是锁住o2,想要获得o1
                                        System.out.println("2");
                                }                        }

                }
        }

        public static void main(String[] args) {
                TestDeadLock td1 = new TestDeadLock();
                TestDeadLock td2 = new TestDeadLock();
                td1.flag = 1;
                td2.flag = 0;
                Thread t1 = new Thread(td1);
                Thread t2 = new Thread(td2);
                t1.start();
                t2.start();
        }
}

搞定，结贴，谢谢。