碼上歡樂
相關內容    簡體    繁體

java中synchronized 用在實例方法和對象方法上面的區別

本文轉載自   查看原文   2018-12-07 15:43   2829 

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  


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Java中synchronized用在靜態方法和非靜態方法上面的區別 Java中靜態方法和實例方法的區別 Java中實例方法和類方法的區別舉例 Java類方法和實例方法的區別 JAVA類與對象（六）------實例變量與類變量的區別，實例方法和類方法的區別 Java中的類變量、實例變量、類方法、實例方法的區別 Java中構造方法、實例方法、類方法的區別 Java中構造方法、實例方法、類方法的區別 java 靜態方法和實例方法的區別 Java靜態方法和實例方法區別詳解
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM