https://bijian1013.iteye.com/blog/1836575

 

 在Java中，synchronized 是用來表示同步的，我們可以synchronized 來修飾一個方法。也可以synchronized 來修飾方法裡面的一個語句塊。

      修飾例項方法：

Java程式碼  

1. public synchronized void normalMethod() throws InterruptedException {  
2.     for (int i = 0; i < 10; i++) {  
3.         Thread.sleep(1000);  
4.         System.out.println("normalMethod:" + i);  
5.     }  
6. }  

      修飾類方法（static 方法）：

Java程式碼  

1. public static synchronized void staticMethod() throws InterruptedException {  
2.     for (int i = 0; i < 10; i++) {  
3.         Thread.sleep(500);  
4.         System.out.println("staticMethod:" + i);  
5.     }  
6. }  

       修飾方法裡面語句塊：

Java程式碼  

1. public static void staticMethod() throws InterruptedException  {    
2.         synchronized (locks) {    
3.             for (int i = 0; i < 10; i++)  {    
4.                 Thread.sleep(1000);    
5.                 System.out.println("staticMethod:" + i);    
6.            }    
7.        }    
8. }    

      注意：這裡不能用synchronized修飾方法外面的語句塊（我把他叫做類語句塊），雖然我們可以在方法外面定義語句塊，這樣做會遇到編譯錯誤，這裡涉及到了Java裡面的物件初始化的部分知識。大概的原因就是synchronized鎖住的是物件，當初始化物件的時候，JVM在物件初始化完成之前會呼叫方法外面的語句塊，這個時候物件還不存在，所以就不存在鎖了。

      那麼，在static方法和非static方法前面加synchronized到底有什麼不同呢？

      static的方法屬於類方法，它屬於這個Class（注意：這裡的Class不是指Class的某個具體物件），那麼static獲取到的鎖，就是當前呼叫這個方法的物件所屬的類(Class，而不再是由這個Class產生的某個具體物件了)。而非static方法獲取到的鎖，就是當前呼叫這個方法的物件的鎖了。所以，他們之間不會產生互斥。

      例項1：

Java程式碼  

1. package com.bijian.thread;  
2.   
3. public class SynchronizedTest {  
4.   
5.     public static synchronized void staticMethod() throws InterruptedException {  
6.         for (int i = 0; i < 10; i++) {  
7.             Thread.sleep(500);  
8.             System.out.println("staticMethod:" + i);  
9.         }  
10.     }  
11.   
12.     public synchronized void normalMethod() throws InterruptedException {  
13.         for (int i = 0; i < 10; i++) {  
14.             Thread.sleep(1000);  
15.             System.out.println("normalMethod:" + i);  
16.         }  
17.     }  
18.   
19.     public static void main(String[] args) {  
20.         final SynchronizedTest synchronizedTest = new SynchronizedTest();  
21.         Thread thread = new Thread(new Runnable() {  
22.             public void run() {  
23.                 try {  
24.                     synchronizedTest.normalMethod();  
25.                 } catch (InterruptedException e) {  
26.                     e.printStackTrace();  
27.                 }  
28.             }  
29.         }, "a");  
30.   
31.         Thread thread1 = new Thread(new Runnable() {  
32.             public void run() {  
33.                 try {  
34.                     SynchronizedTest.staticMethod();  
35.                 } catch (InterruptedException e) {  
36.                     e.printStackTrace();  
37.                 }  
38.             }  
39.         }, "b");  
40.   
41.         thread1.start();  
42.         thread.start();  
43.     }  
44. }  

       執行結果：

Text程式碼  

1. staticMethod:0  
2. normalMethod:0  
3. staticMethod:1  
4. staticMethod:2  
5. normalMethod:1  
6. staticMethod:3  
7. staticMethod:4  
8. normalMethod:2  
9. staticMethod:5  
10. staticMethod:6  
11. normalMethod:3  
12. staticMethod:7  
13. staticMethod:8  
14. normalMethod:4  
15. staticMethod:9  
16. normalMethod:5  
17. normalMethod:6  
18. normalMethod:7  
19. normalMethod:8  
20. normalMethod:9  

       那當我們想讓所有這個類下面的物件都同步的時候，也就是讓所有這個類下面的物件共用同一把鎖的時候，我們如何辦呢？

       法1：將normalMethod方法也改成static,這樣這兩個static方法都屬於類方法，它們獲取到的鎖都是當前呼叫這個方法的物件所屬的類(Class，而不再是由這個Class產生的某個具體物件了)。但這樣會影響程式碼結構和物件的封裝性。

       修改例項1如下：

Java程式碼  

1. package com.bijian.thread;  
2.   
3. public class SynchronizedTest {  
4.     public static synchronized void staticMethod() throws InterruptedException {  
5.         for (int i = 0; i < 10; i++) {  
6.             Thread.sleep(500);  
7.             System.out.println("staticMethod:" + i);  
8.         }  
9.     }  
10.     public static synchronized void normalMethod() throws InterruptedException {  
11.         for (int i = 0; i < 10; i++) {  
12.             Thread.sleep(1000);  
13.             System.out.println("normalMethod:" + i);  
14.         }  
15.     }  
16.   
17.     public static void main(String[] args) {  
18.         Thread thread = new Thread(new Runnable() {  
19.             public void run() {  
20.                 try {  
21.                     SynchronizedTest.normalMethod();  
22.                 } catch (InterruptedException e) {  
23.                     e.printStackTrace();  
24.                 }  
25.             }  
26.         }, "a");  
27.           
28.         Thread thread1 = new Thread(new Runnable() {  
29.             public void run() {  
30.                 try {  
31.                     SynchronizedTest.staticMethod();  
32.                 } catch (InterruptedException e) {  
33.                     e.printStackTrace();  
34.                 }  
35.             }  
36.         }, "b");  
37.   
38.         thread1.start();  
39.         thread.start();  
40.     }  
41. }  

       執行結果：

Text程式碼  

1. staticMethod:0  
2. staticMethod:1  
3. staticMethod:2  
4. staticMethod:3  
5. staticMethod:4  
6. staticMethod:5  
7. staticMethod:6  
8. staticMethod:7  
9. staticMethod:8  
10. staticMethod:9  
11. normalMethod:0  
12. normalMethod:1  
13. normalMethod:2  
14. normalMethod:3  
15. normalMethod:4  
16. normalMethod:5  
17. normalMethod:6  
18. normalMethod:7  
19. normalMethod:8  
20. normalMethod:9  

       也許有人說：將例項1的staticMethod方法改成的static去掉也能達到目的。確實可以，因為非static方法獲取到的鎖，就是當前呼叫這個方法的物件的鎖，而例項1只有一個SynchronizedTest例項，如再建立一個例項，則就有問題了。如下所示：

         

Java程式碼  

1. package com.bijian.thread;  
2.   
3. public class SynchronizedTest {  
4.   
5.     public synchronized void staticMethod() throws InterruptedException {  
6.         for (int i = 0; i < 10; i++) {  
7.             Thread.sleep(500);  
8.             System.out.println("staticMethod:" + i);  
9.         }  
10.     }  
11.   
12.     public synchronized void normalMethod() throws InterruptedException {  
13.         for (int i = 0; i < 10; i++) {  
14.             Thread.sleep(1000);  
15.             System.out.println("normalMethod:" + i);  
16.         }  
17.     }  
18.   
19.     public static void main(String[] args) {  
20.         final SynchronizedTest synchronizedTest = new SynchronizedTest();  
21.         Thread thread = new Thread(new Runnable() {  
22.             public void run() {  
23.                 try {  
24.                     synchronizedTest.normalMethod();  
25.                 } catch (InterruptedException e) {  
26.                     e.printStackTrace();  
27.                 }  
28.             }  
29.         }, "a");  
30.   
31.         //為了驗證獲取到的鎖都是當前呼叫這個方法的物件所屬的類，特另新建一個物件  
32.         final SynchronizedTest synchronizedTest2 = new SynchronizedTest();  
33.           
34.         Thread thread1 = new Thread(new Runnable() {  
35.             public void run() {  
36.                 try {  
37.                     synchronizedTest2.staticMethod();  
38.                 } catch (InterruptedException e) {  
39.                     e.printStackTrace();  
40.                 }  
41.             }  
42.         }, "b");  
43.   
44.         thread1.start();  
45.         thread.start();  
46.     }  
47. }  

       執行結果：

Text程式碼  

1. staticMethod:0  
2. staticMethod:1  
3. normalMethod:0  
4. staticMethod:2  
5. staticMethod:3  
6. normalMethod:1  
7. staticMethod:4  
8. staticMethod:5  
9. normalMethod:2  
10. staticMethod:6  
11. normalMethod:3  
12. staticMethod:7  
13. staticMethod:8  
14. normalMethod:4  
15. staticMethod:9  
16. normalMethod:5  
17. normalMethod:6  
18. normalMethod:7  
19. normalMethod:8  
20. normalMethod:9  

 

       法2：語句塊鎖，直接看如下例項：

       例項2：

Java程式碼  

1. package com.bijian.thread;  
2.   
3. public class SynchronizedTest {  
4.   
5.     public final static Byte[] locks = new Byte[0];    
6.   
7.     public static void staticMethod() throws InterruptedException {  
8.         synchronized(locks) {  
9.             for (int i = 0; i < 10; i++) {  
10.                 Thread.sleep(500);  
11.                 System.out.println("staticMethod:" + i);  
12.             }  
13.         }  
14.     }  
15.   
16.     public void normalMethod() throws InterruptedException {  
17.         synchronized(locks) {  
18.             for (int i = 0; i < 10; i++) {  
19.                 Thread.sleep(1000);  
20.                 System.out.println("normalMethod:" + i);  
21.             }  
22.         }  
23.     }  
24.   
25.     public static void main(String[] args) {  
26.         final SynchronizedTest synchronizedTest = new SynchronizedTest();  
27.         Thread thread = new Thread(new Runnable() {  
28.             public void run() {  
29.                 try {  
30.                     synchronizedTest.normalMethod();  
31.                 } catch (InterruptedException e) {  
32.                     e.printStackTrace();  
33.                 }  
34.             }  
35.         }, "a");  
36.   
37.         Thread thread1 = new Thread(new Runnable() {  
38.             public void run() {  
39.                 try {  
40.                     SynchronizedTest.staticMethod();  
41.                 } catch (InterruptedException e) {  
42.                     e.printStackTrace();  
43.                 }  
44.             }  
45.         }, "b");  
46.   
47.         thread1.start();  
48.         thread.start();  
49.     }  
50. }  

       執行結果：

Text程式碼  

1. staticMethod:0  
2. staticMethod:1  
3. staticMethod:2  
4. staticMethod:3  
5. staticMethod:4  
6. staticMethod:5  
7. staticMethod:6  
8. staticMethod:7  
9. staticMethod:8  
10. staticMethod:9  
11. normalMethod:0  
12. normalMethod:1  
13. normalMethod:2  
14. normalMethod:3  
15. normalMethod:4  
16. normalMethod:5  
17. normalMethod:6  
18. normalMethod:7  
19. normalMethod:8  
20. normalMethod:9