关于synchroized（）的钥匙问题，我写了一个测试问题，得出的结论是在两个不同的线程中，只有当钥匙出来之后才能打开另一个把锁，之前一直搞不懂，现在好像明白了死锁问题，在同一时间，两把不同的锁相互需要，而且不能“拔出钥匙”的时候会出现死锁，测试代码如下，不知道有没有同学需要的，分享出来吧。

1. import java.util.Date;
   
2. 
   
3. 
   
4. public class SychronizedName {
   
5. 
   
6.         /**
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 // TODO Auto-generated method stub
    
11.                 TestSynchronized1 t1 = new TestSynchronized1();
    
12.                 TestSynchronized2 t2 = new TestSynchronized2();
    
13.                 Thread th1 =new Thread (t1);
    
14.                 Thread th2 =new Thread (t2);
    
15.                 th2.start();
    
16.                 try{Thread.sleep(10);}catch(Exception e){}
    
17.                 th1.start();       
    
18.         }
    
19. 
    
20. }
    
21. 
    
22. class MyLock{
    
23.         static Object locka = new Object();
    
24.         static Object lockb = new Object();
    
25. }
    
26. 
    
27. class TestSynchronized1 implements Runnable{
    
28. 
    
29.         public void run() {
    
30.                 synchronized(MyLock.locka){
    
31.                         System.out.println("执行TestSynchronized1"+""+ new Date());
    
32.                         synchronized(MyLock.lockb){       
    
33.                                 System.out.println(MyLock.locka.toString() +""+ new Date()+" lockb1");
    
34.                         }
    
35.                         try{Thread.sleep(5000);}catch(Exception e){}
    
36.                         System.out.println(MyLock.lockb.toString()+""+ new Date()+" locka1");
    
37.                 }
    
38.                
    
39.         }
    
40. }
    
41. class TestSynchronized2 implements Runnable{
    
42. 
    
43.         public void run() {
    
44.                 synchronized(MyLock.lockb){
    
45.                         System.out.println("执行TestSynchronized2"+""+ new Date());
    
46.                         try{Thread.sleep(2000);}catch(Exception e){}
    
47.                         System.out.println(MyLock.locka.toString() +""+ new Date()+" lockb2");
    
48.                 }
    
49.                
    
50.         }
    
51.        
    
52. }

复制代码

执行TestSynchronized2Sat Mar 22 00:38:40 CST 2014//说明两个线程几乎同时执行，但是一定是线程2先执行10毫秒
执行TestSynchronized1Sat Mar 22 00:38:40 CST 2014//说明两个线程几乎同时执行，但是一定是线程2先执行10毫秒
java.lang.Object@5d391dSat Mar 22 00:38:42 CST 2014 lockb2//说明线程1中的b锁实在线程2中b锁出来的时候才开的锁
java.lang.Object@5d391dSat Mar 22 00:38:42 CST 2014 lockb1//说明线程1中的b锁实在线程2中b锁出来的时候才开的锁,所有时间晚了2秒后同时打印
java.lang.Object@d507e9Sat Mar 22 00:38:47 CST 2014 locka1//说明钥匙在使用时依然可以调用，但是不能开锁

顶一下！

以前理解死锁的时候是瞬间懂了， 然后想写个死锁，用了3个小时:L