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

复制代码

大家好  关于这段代码我有2点疑惑。
第一个问题就是static可以修饰成员变量和成员函数。这句话Object locka=new Object();为什么可以被static修饰呀?
第二个问题就是加上了静态以后就多了一种调用方式，就是可以直接被类名所调用，调用的是方法，而locka和lockb都
是对象的引用，为什么还可以被类名调用呢？难道我学死了！麻烦仁兄们帮小弟解答下疑惑。谢谢了。

这个我也不太懂，，帮你顶一下

汉谟拉比 发表于 2014-7-12 21:20
这个我也不太懂，，帮你顶一下

汗！{:3_55:}