2. 程式人生 > >synchronized 用在例項方法和類方法的區別

synchronized 用在例項方法和類方法的區別

阿新 • • 發佈：2019-02-09
在Java中，synchronized 是用來表示同步的，我們可以synchronized 來修飾一個方法。也可以synchronized 來修飾方法裡面的一個語句塊。

      修飾例項方法：

Java程式碼  收藏程式碼
  1. publicsynchronizedvoid 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. publicstaticsynchronizedvoid 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. publicstaticvoid 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. publicclass SynchronizedTest {  
  3.     publicstaticsynchronizedvoid staticMethod() throws InterruptedException {  
  4.         for (int i = 0; i < 10; i++) {  
  5.             Thread.sleep(500);  
  6.             System.out.println("staticMethod:" + i);  
  7.         }  
  8.     }  
  9.     publicsynchronizedvoid normalMethod() throws InterruptedException {  
  10.         for (int i = 0; i < 10; i++) {  
  11.             Thread.sleep(1000);  
  12.             System.out.println("normalMethod:" + i);  
  13.         }  
  14.     }  
  15.     publicstaticvoid main(String[] args) {  
  16.         final SynchronizedTest synchronizedTest = new SynchronizedTest();  
  17.         Thread thread = new Thread(new Runnable() {  
  18.             publicvoid run() {  
  19.                 try {  
  20.                     synchronizedTest.normalMethod();  
  21.                 } catch (InterruptedException e) {  
  22.                     e.printStackTrace();  
  23.                 }  
  24.             }  
  25.         }, "a");  
  26.         Thread thread1 = new Thread(new Runnable() {  
  27.             publicvoid run() {  
  28.                 try {  
  29.                     SynchronizedTest.staticMethod();  
  30.                 } catch (InterruptedException e) {  
  31.                     e.printStackTrace();  
  32.                 }  
  33.             }  
  34.         }, "b");  
  35.         thread1.start();  
  36.         thread.start();  
  37.     }  
  38. }  

       執行結果：

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. publicclass SynchronizedTest {  
  3.     publicstaticsynchronizedvoid staticMethod() throws InterruptedException {  
  4.         for (int i = 0; i < 10; i++) {  
  5.             Thread.sleep(500);  
  6.             System.out.println("staticMethod:" + i);  
  7.         }  
  8.     }  
  9.     publicstaticsynchronizedvoid normalMethod() throws InterruptedException {  
  10.         for (int i = 0; i < 10; i++) {  
  11.             Thread.sleep(1000);  
  12.             System.out.println("normalMethod:" + i);  
  13.         }  
  14.     }  
  15.     publicstaticvoid main(String[] args) {  
  16.         Thread thread = new Thread(new Runnable() {  
  17.             publicvoid run() {  
  18.                 try {  
  19.                     SynchronizedTest.normalMethod();  
  20.                 } catch (InterruptedException e) {  
  21.                     e.printStackTrace();  
  22.                 }  
  23.             }  
  24.         }, "a");  
  25.         Thread thread1 = new Thread(new Runnable() {  
  26.             publicvoid run() {  
  27.                 try {  
  28.                     SynchronizedTest.staticMethod();  
  29.                 } catch (InterruptedException e) {  
  30.                     e.printStackTrace();  
  31.                 }  
  32.             }  
  33.         }, "b");  
  34.         thread1.start();  
  35.         thread.start();  
  36.     }  
  37. }  

       執行結果：

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

       執行結果：

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

       執行結果：

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

相關推薦

synchronized 用在例項方法和類方法的區別

在Java中，synchronized 是用來表示同步的，我們可以synchronized 來修飾一個方法。也可以synchronized 來修飾方法裡面的一個語句塊。       修飾例項方法： Java程式碼   publicsynchronizedvoid no

JAVA中例項變數與類變數的區別，例項方法和類方法的區別

class TiXing{ private float up,height; private static float down; TiXing(float x,float y,float z){ up=x; height=y;

例項方法和類方法區別

1、類方法是屬於整個類，而不屬於某個物件。 2、類方法只能訪問類成員變數，不能訪問例項變數，而例項方法可以訪問類成員變數和例項變數。 3、類方法的呼叫可以通過類名.類方法和物件.類方法，而例項方法只能

類屬性、例項屬性，靜態方法和類方法

類屬性、例項屬性 在瞭解了類基本的東西之後，下面看一下python中這幾個概念的區別 先來談一下類屬性和例項屬性 在前面的例子中我們接觸到的就是例項屬性（物件屬性），顧名思義，類屬性就是類物件所擁有的屬性，它被所有類物件的例項物件所共有，在記憶體中只存在一個副本，這個和C++中類的靜

python進階14：例項方法和類方法、types.MethodType()

1 例項方法   一個例項的私有屬性就是以__開頭的屬性，無法被外部訪問，那這些屬性定義有什麼用？雖然私有屬性無法從外 部訪問，但是，從類的內部是可以訪問的。除了可以定義例項的屬性外，還可以定義例項的方法。例項的方法就是在 類中定義的函式，它的第一個引數永遠是 self，指

Python 靜態方法和類方法的區別

python staticmethod and classmethodThough classmethod and staticmethod are quite similar, there’s a slight difference in usage for both en

python 普通方法、靜態方法和類方法有什麼區別?

下面用例子的方式，說明其區別。 首先， 定義一個類，包括3個方法： class Apple(object): def get_apple(self, n): print "apple: %s,%s" % (

例項方法,構造方法和類方法小結

例項方法:可以通過類的例項呼叫物件的方法，也稱成員方法.構造方法:構造方法的特點方法名與類名相同。沒有返回值。（沒有return，沒有void）不能被除訪問修飾符外的任何修飾符訪問。不能被子類繼承。父級的構造方法不能被子類呼叫，可以通過super語句呼叫父類的構造方法，加入在

OC例項方法和類方法建立的物件區別是什麼

arrayWithArray和initWithArray的區別 建立一個數組的時候經常使用初始化方法initWithArray或者便利構造方法arrayWithArray來建立，比如： NSArray *arr = @[@"1"]; NSMutable

Python類的例項方法、靜態方法和類方法

class Foo(object): """類三種方法語法形式""" def instance_method(self): print("是類{}的例項方法，只能被例項

python基礎2-靜態方法和類方法

變量 img 靜態 訪問 func title 改變 參數 code 1. 類方法 是類對象所擁有的方法，需要用修飾器@classmethod來標識其為類方法，對於類方法，第一個參數必須是類對象，一般以cls作為第一個參數（當然可以用其他名稱的變量作為其第一個參數，但是大部

Python的靜態方法和類方法

cts -i ack diff 繼承 ssm from 靜態方法 print Python中使用@staticmethod這個裝飾器讓方法變為靜態方法 一：定義 @staticmethod： 首先它是一個裝飾器，被裝飾的方法不需要隱含的參數，對象和對象的實例都可以調用靜態方

Python3的靜態方法和類方法

使用 定義 多個 並且 實例化 icm color ont cls 靜態方法和類方法的創建： 將它們分別包裝在staticmethod和classmethod類的對象中。 靜態方法的定義中沒有參數self，可直接通過類來調用。 類方法的定義中包含類似於self的參數，通常被

靜態方法和類方法

英雄 per 初始 ati 出了 class cme turn python 1、類方法：@classmethod 如下例子： class Hero(object): __height = 1 # 英雄高度 def __init__(self, name,

Python面向對象之靜態方法和類方法

pac local 面向對象語言 borde border time cme def 靜態方法 常規的類定義中，所有函數都被假定在實例上操作，該實例總是作為第一個參數self傳遞。但還有可以定義兩種常見的方法。 靜態方法是一種普通函數，它不會對任何實例類型進行操作。使用@s

【轉】Python基礎-封裝與擴充套件、靜態方法和類方法

【轉】Python基礎-封裝與擴充套件、靜態方法和類方法 一、封裝與擴充套件 封裝在於明確區分內外，使得類實現者可以修改封裝內的東西而不影響外部呼叫者的程式碼；而外部使用者只知道一個介面(函式)，只要介面（函式）名、引數不變，使用者的程式碼永遠無需改變。這就提供一個良好的合作基礎——或者說，只要介面這個基

python學習日記（OOP——靜態方法和類方法）

classmethod 類方法在Python中使用比較少，類方法傳入的第一個引數為cls，是類本身。並且，類方法可以通過類直接呼叫，或通過例項直接呼叫。但無論哪種呼叫方式，最左側傳入的引數一定是類本身。 通常情況下，類方法使用@classmethod裝飾器來宣告 當這個方法的操作只涉及靜態屬性的時候 就

Python基礎筆記_Day11_Python單繼承、多繼承、重寫方法、Python多型、Python靜態方法和類方法

Day11_Python單繼承、多繼承、重寫方法、Python多型、Python靜態方法和類方法 11.01_Python語言基礎(繼承的介紹)(掌握) 11.02_Python語言基礎(單繼承)(掌握) 11.03_Python語言基礎(多繼承)(掌握) 11.04_Python語言基

OC的物件方法和類方法筆記

設定test的類方法和物件方法 #import <Foundation/Foundation.h> @interface Person : NSObject 類方法都是以+開頭 +(void)test; 物件方法都以-開頭 (adsbygoogle = win

Python 靜態方法和類方法

靜態方法 我們知道在其他語言中靜態方法一般使用static修飾，靜態方法的主要特點是不需要new出物件，直接通過類名就可以訪問，也可以通過物件訪問。需要使用staticmethod裝飾器裝飾方法 舉例： class A: @staticmethod