大家帮忙看看，为什么我的代码运行起来一直都是和谐的  没有发生死锁，是不是代码有问题？


package test;

public class TestSynchronized implements Runnable{

        Object a = new Object();
        //Object b = new Object();
        private boolean flag ;
        TestSynchronized(boolean flag){
                this.flag = flag;
        }
        @Override
        public void run() {
                // TODO Auto-generated method stub
                if(flag)
                {
                        while(true){
                        synchronized(a){
                                try {
                                        Thread.sleep(100);
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                                System.out.println("if run a");
                                synchronized(this){
                                        System.out.println("if run b");
                                }
                        }
                }
        }
                else{
                        while(true){
                        synchronized(this){
                                try {
                                        Thread.sleep(100);
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                                System.out.println("else run b");
                                synchronized(a){
                                        System.out.println("else run a");
                                }
                        }
                }
        }
        }
}


package test;

public class TestSynchronizedDemo {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
               
                Thread t1 = new Thread(new TestSynchronized(true));
                Thread t2 = new Thread(new TestSynchronized(false));
                t1.start();
                t2.start();
        }

}

感觉对锁理解的也是一般，但是还能看出你这代码里面没有定义锁。你的a锁和b锁是怎么来的，我也没有想明白。我把代码调通了，你参考一下吧。另外死锁两把钥匙开两个房门是同时进行的，所以运行的结果是随机的。

1. package deadLock;
   
2. class TestSynchronized  implements Runnable{
   
3. 
   
4.         Object a = new Object();
   
5.         //Object b = new Object();
   
6.         private boolean flag ;
   
7.         TestSynchronized (boolean flag){
   
8.                 this.flag = flag;
   
9.         }
   
10.         @Override
    
11.         public void run() {
    
12.                 if(flag)
    
13.                 {
    
14.                     while(true){
    
15.                             //拿着a钥匙去开a门进到了a的房间
    
16.                             synchronized(Mylock.a){
    
17.                             try {
    
18.                                     Thread.sleep(10);
    
19.                             } catch (InterruptedException e) {
    
20.                                     e.printStackTrace();
    
21.                             }
    
22.                                     System.out.println("if run a");
    
23.                                     //a房间里面还有一个房间，需要用b钥匙去开，但是a在拿a钥匙开a房门的同时，b已经把b钥匙拿走了，所以a在这个位置被锁死了。
    
24.                             synchronized(Mylock.b){
    
25.                             System.out.println("if run b");
    
26.                             }
    
27.                             }
    
28.                 }
    
29.         }
    
30.                 else{
    
31.                     while(true){
    
32.                             //在这b被锁死的原理跟上面一样
    
33.                             synchronized(Mylock.b){
    
34.                                     try {
    
35.                                             Thread.sleep(10);
    
36.                                     } catch (InterruptedException e) {
    
37.                                             e.printStackTrace();
    
38.                                     }
    
39.                                     System.out.println("else run b");
    
40.                                     synchronized(Mylock.a){
    
41.                                             System.out.println("else run a");
    
42.                                     }
    
43.                             }
    
44.                 }
    
45.         }
    
46.         }
    
47. }
    
48. //定义两把锁
    
49. class Mylock
    
50. {
    
51.         public static Object a = new Object();
    
52.         public static Object b = new Object();
    
53. }
    
54. public class Lock {
    
55. 
    
56.         /**
    
57.          * @param args
    
58.          */
    
59.         public static void main(String[] args) {
    
60.                 // TODO Auto-generated method stub
    
61.                
    
62.                 Thread t1 = new Thread(new TestSynchronized (true));
    
63.                 Thread t2 = new Thread(new TestSynchronized (false));
    
64.                 t1.start();
    
65.                 t2.start();
    
66.         }
    
67. 
    
68. }
    

复制代码

毕老师说的两个前提！！！！你看看你用的是不是同一个锁？你这里this对应两个不同的对象，a也对应两个不同的对象，把a搞成static的，然后再搞多一个b也是static的，或者写一个类，里面有两把锁，这样也可以