1. <p>
   
2. 
   
3. class Test implements Runnable
   
4. {
   
5.         private boolean flag;
   
6.         Test(boolean flag)
   
7.         {
   
8.                 this.flag = flag;
   
9.         }
   
10. 
    
11.         public void run()
    
12.         {
    
13.                 if(flag)
    
14.                 {
    
15.                         while(true)
    
16.                         {
    
17.                                 synchronized(MyLock.locka)
    
18.                                 {
    
19.                                         System.out.println(Thread.currentThread().getName()+"...if locka ");
    
20.                                         synchronized(MyLock.lockb)
    
21.                                         {
    
22.                                                 System.out.println(Thread.currentThread().getName()+"..if lockb");                                       
    
23.                                         }
    
24.                                 }
    
25.                         }
    
26.                 }
    
27.                 else
    
28.                 {
    
29.                         while(true)
    
30.                         {
    
31.                                 synchronized(MyLock.lockb)
    
32.                                 {
    
33.                                         System.out.println(Thread.currentThread().getName()+"..else lockb");
    
34.                                         synchronized(MyLock.locka)
    
35.                                         {
    
36.                                                 System.out.println(Thread.currentThread().getName()+".....else locka");
    
37.                                         }
    
38.                                 }
    
39.                         }
    
40.                 }
    
41.         }
    
42. }
    
43. 
    
44. 
    
45. class MyLock
    
46. {
    
47.         static Object locka = new Object();
    
48.         static Object lockb = new Object();
    
49. }
    
50. 
    
51. class  DeadLockTest
    
52. {
    
53.         public static void main(String[] args)
    
54.         {
    
55.                 Thread t1 = new Thread(new Test(true));
    
56.                 Thread t2 = new Thread(new Test(false));
    
57.                 t1.start();
    
58.                 t2.start();
    
59.         }
    
60. }
    
61. 在以上的代码中，有两个锁，MyLock.locka和MyLock.lockb，这两个锁这样交叉使用出现了死锁，为了避免这个情况，在class MyLock中，再创建两个锁  static Object lockc = new Object();    static Object lockd = new Object();然后把这两个锁去替换上面程序中重复的锁，这样不就可以解决死锁了吗，这只是我的一点小小的想法和疑虑，欢迎大神来讨论和指正。</p>

复制代码

你以为他们为什么要用一样的锁呢？
加个c，d跟把a，b全扔了效果是一样的，后者效率还高点。。

你没有理解锁的本质。。。。。
给你举个例子来理解一下吧。
想象一下：有一个热水器，有两个出水口(A,B)，每个口都需要把卡贴在射频识别的模块上才能出水，但是只有一张卡。
你想一下，是不是两个出水口一次只能有一个出水？
如果像你的写法，就相当于两个出水口，都有自己的卡，可以同时出水。
可能例子举的不够形象，给你从代码上说一下吧
synchronized(A对象)           
{
}
这里的对象A，相当于一个钥匙，当一个线程(C)先进入了synchronized代码块，相当于打开了一个门，就会执行代码块里面的内容，那么另一个线程(B)，也执行到synchronized代码块时，发现这个钥匙(A)被线程C拿着，他打不开这个门，就会一直等啊，一直等，等到C的同步代码执行完了，把钥匙A交出来了，这时B就能拿钥匙A开B线程这个门了，即可以执行B的同步代码块了。。。。。

说的有点啰嗦，不过，应该能看懂吧？