在类中给2个以上的静态方法加synchronized时，那么线程会不会同时进入这2个静态方法？线程如果同时执行类中的非静态方法，如果这个时候类中的非静态方法修改了静态变量的值，那静态变量的同步岂不是失败了么

写了个例子验证了一下：

1. package test;
   
2. 
   
3. import myutil.SOP;
   
4. 
   
5. public class TestSynchronized2 {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          * @throws InterruptedException
   
10.          */
    
11.         public static void main(String[] args) throws InterruptedException {
    
12.                 // TODO Auto-generated method stub
    
13.                 MySync2 ms1 = new MySync2();
    
14.                 ms1.setFlag(1);
    
15.                 MySync2 ms2 = new MySync2();
    
16.                 ms2.setFlag(2);
    
17.                 MySync2 ms3 = new MySync2();
    
18.                 ms3.setFlag(3);
    
19.                
    
20.                 Thread t1 = new Thread(ms1);
    
21.                 Thread t2 = new Thread(ms2);
    
22.                 Thread t3 = new Thread(ms3);
    
23.                 t1.start();
    
24.                 Thread.sleep(100);
    
25.                 t2.start();
    
26.                 t3.start();
    
27.         }
    
28. 
    
29. }
    
30. 
    
31. class MySync2 implements Runnable{
    
32.         private int flag = 0;
    
33.         private static int i = 0;
    
34.        
    
35.         public void setFlag(int flag) {
    
36.                 this.flag = flag;
    
37.         }
    
38.        
    
39.         static synchronized void method1() throws InterruptedException{
    
40.                 i=10;
    
41.                 Thread.sleep(5000);
    
42.                 SOP.sop("method1---"+i);
    
43.         }
    
44.         static synchronized void method2() throws InterruptedException{
    
45.                 i=20;
    
46.                 Thread.sleep(2000);
    
47.                 SOP.sop("method2---"+i);
    
48.         }
    
49.         void method3() throws InterruptedException{
    
50.                 i = 1000;
    
51.                 SOP.sop("method3---"+i);
    
52.         }
    
53.         @Override
    
54.         public void run() {
    
55.                 switch (flag) {
    
56.                 case 1:
    
57.                         try {
    
58.                                 method1();
    
59.                         } catch (InterruptedException e) {
    
60.                                 // TODO Auto-generated catch block
    
61.                                 e.printStackTrace();
    
62.                         }
    
63.                         break;
    
64.                 case 2:
    
65.                         try {
    
66.                                 method2();
    
67.                         } catch (InterruptedException e) {
    
68.                                 // TODO Auto-generated catch block
    
69.                                 e.printStackTrace();
    
70.                         }
    
71.                         break;
    
72.                 case 3:
    
73.                         try {
    
74.                                 method3();
    
75.                         } catch (InterruptedException e) {
    
76.                                 // TODO Auto-generated catch block
    
77.                                 e.printStackTrace();
    
78.                         }
    
79.                         break;
    
80. 
    
81.                 default:
    
82.                         SOP.sop("here is default");
    
83.                         break;
    
84.                 }
    
85.                 // TODO Auto-generated method stub
    
86.                
    
87.         }
    
88. }

复制代码

结果是：
method3---1000
method1---1000
method2---20

得出的结论是：
静态方法的默认的锁是类本身，所以两个静态的方法是不可能同时被调用的，只有一前一后的顺序。但是非静态方法就不一定了。
上面这个例子的情况是：
t1先把 i 改成10，然后锁上，这时候t2不可以进来了，但是因为t3不受锁的限制，进来把 i 改成1000 并且输出，后来t1醒来后，i 已经变成1000了，所以输出1000，t1释放所后，t2再进来，把 i 改成20，然后输出20.