1. class Test implements Runnable
   
2. {
   
3.        
   
4.         private boolean flag;
   
5.         Test(boolean flag)
   
6.         {
   
7.                 this.flag=flag;
   
8.                 }
   
9.         public void run()
   
10.         {
    
11.                 if(flag)
    
12.                 {
    
13.                         while(true)
    
14.                         {
    
15.                         synchronized(Lock.Locka)
    
16.                         {
    
17.                                 System.out.println("if locka");
    
18.                                 synchronized(Lock.Lockb)
    
19.                                 {
    
20.                                         System.out.println("if lockb");
    
21.                                         }
    
22.                                 }
    
23.                         }
    
24.                         }
    
25.                 else
    
26.                 {
    
27.                         while(true)
    
28.                         {
    
29.                         synchronized(Lock.Lockb)
    
30.                         {
    
31.                                 System.out.println("else lockb");
    
32.                                 synchronized(Lock.Locka)
    
33.                                 {
    
34.                                         System.out.println("else locka");
    
35.                                         }
    
36.                         }
    
37.                 }
    
38.                 }
    
39.         }
    
40. }
    
41. 
    
42. class Lock
    
43. {
    
44.         static Object Locka=new Object();
    
45.         static Object Lockb=new Object();
    
46.         }
    
47. 
    
48. class DeadLockDemo1
    
49. {
    
50.         public static void main(String[] args)
    
51.         {
    
52.                 Thread t1=new Thread(new Test(true));
    
53.                 Thread t2=new Thread(new Test(false));
    
54.                 t1.start();
    
55.                 t2.start();
    
56.                 }
    
57.         }
    
58.        

复制代码

这段是可以实现死锁的，下面这段是有问题的，请帮忙分析一下区别

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

复制代码

额 没人肯帮忙吗？

Fightingforever 发表于 2014-10-22 08:35
额 没人肯帮忙吗？

楼主，我来分析一下吧，第一段代码之所以能够实现死锁，是因为两个线程是用同样的两个锁，只不过锁的顺序相反，因此会造成两个线程拿到相反的锁然后都未释放，因此双方都无法进入。
楼主第二段的代码中，两个线程制造了其实不是两个锁，是四个锁，因为每一次new Test()都创建了两个锁，第一个线程的两个锁和第二个线程的两个锁是不一样的锁，因此彼此间不相互影响，不会造成死锁，楼主只需要把Object Locka=new Object();和 Object Lockb=new Object();都变成static Object Locka=new Object(); static Object Lockb=new Object();就可以了，因为这样的情况下，即便new Test()两次，两个线程的两个锁分别都是一样的，因此可以就会造成和第一段代码一样的结果。

罗林军 发表于 2014-10-22 10:46
楼主，我来分析一下吧，第一段代码之所以能够实现死锁，是因为两个线程是用同样的两个锁，只不过锁的顺序 ...

太感谢啦  我犯了低级错误！

罗林军 发表于 2014-10-22 10:46
楼主，我来分析一下吧，第一段代码之所以能够实现死锁，是因为两个线程是用同样的两个锁，只不过锁的顺序 ...

真心很感激！

Fightingforever 发表于 2014-10-22 11:00
真心很感激！

楼主不用客气啦，论坛本来就是交流学习的，，祝楼主早日通过黑马考试哦，

罗林军 发表于 2014-10-22 11:03
楼主不用客气啦，论坛本来就是交流学习的，，祝楼主早日通过黑马考试哦，
...

好的好的 一起加油！

下面这段是因为new Test（），所以两个线程有两个locka、两个lockb锁而上面的是各自只有一个，所以能死锁