2. 程式人生 > >synchronized修飾普通方法，修飾靜態方法比較

synchronized修飾普通方法，修飾靜態方法比較

阿新 • • 發佈：2018-11-27

一、synchronized修飾普通方法

初始化一個物件時，會自動生成一個與該物件對應的物件鎖，被synchronized 修飾的方法就得依靠物件鎖工作。當多執行緒同時訪問某個被synchronized修飾的方法時，一旦某個程序搶得物件鎖之後，其他的程序只有排隊對待。

例如，Person類裡有2個被synchronized 修飾的方法，…還是看程式碼吧：

public  class Person {

    public synchronized void eatApple() {
        Log.d("TAG", "eatApple begin at:" + System.currentTimeMillis());
        SystemClock.sleep(3000
 
);
        Log.d("TAG", "eatApple end at:" + System.currentTimeMillis());
    }

    public synchronized void eatOrange() {
        for (int i = 0; i < 10; i++) {
            Log.d("TAG", "eatOrange is running");
            SystemClock.sleep(200);
        }
    }
}
public class MainActivity extends
 
 AppCompatActivity {

    Person person = new Person();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        thread1.start();
        thread2.start();
    }

    Thread thread1 = new
 
 Thread(new Runnable() {
        @Override
        public void run() {
            person.eatApple();
        }
    });

    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            person.eatOrange();
        }
    });

}

執行結果：

12-14 16:26:48.243 14867-14920/com.example.shengqf.myapplication D/TAG: eatApple begin at:1513240008242
12-14 16:26:51.244 14867-14920/com.example.shengqf.myapplication D/TAG: eatApple end at:1513240011243
12-14 16:26:51.246 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:51.447 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:51.648 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:51.848 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:52.049 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:52.250 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:52.451 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:52.652 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:52.853 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:26:53.055 14867-14921/com.example.shengqf.myapplication D/TAG: eatOrange is running

結論：因為thread1中的eatApple()方法和thread2中的eatOrange()方法都是通過person物件呼叫的，他們用的是同一個物件鎖，互斥。所以，thread2一直等到thread1中的eatApple()方法執行完釋放了物件鎖後才開始執行其eatOrange()方法。

現在將上面thread2程式碼改一下：

  Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            Person person2 = new Person();
            person2.eatOrange();
        }
    });

再執行，結果：


12-14 16:43:05.011 16294-16320/com.example.shengqf.myapplication D/TAG: eatApple begin at:1513240985011
12-14 16:43:05.011 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:05.211 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:05.412 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:05.612 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:05.813 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:06.014 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:06.215 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:06.416 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:06.617 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:06.818 16294-16321/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-14 16:43:08.012 16294-16320/com.example.shengqf.myapplication D/TAG: eatApple end at:1513240988011

因為thread1中的eatApple()方法是通過person物件呼叫的，而thread2中的eatOrange()方法是通過person2物件呼叫的，他們用的是兩個不同的物件鎖，並不互斥。所以，thread2中的eatOrange()方法是和thread1中的eatApple()方法同時進行的。

結論：使用“同一個物件”去呼叫其被synchronized 修飾的普通方法才互斥。

上面的Person類等效於：

public class Person{

    public void eatApple() {
        synchronized(Person.this){
            Log.d("TAG", "eatApple begin at:" + System.currentTimeMillis());
            SystemClock.sleep(3000);
            Log.d("TAG", "eatApple end at:" + System.currentTimeMillis());
        }
    }

    public void eatOrange() {
        synchronized (Person.this) {
            for (int i = 0; i < 10; i++) {
                Log.d("TAG", "eatOrange is running");
                SystemClock.sleep(200);
            }
        }
    }
}

二、synchronized修飾靜態方法

直接看程式碼：

public class Person {

    public synchronized static void eatApple() {
        Log.d("TAG", "eatApple begin at:" + System.currentTimeMillis());
        SystemClock.sleep(3000);
        Log.d("TAG", "eatApple end at:" + System.currentTimeMillis());
    }

    public synchronized static void eatOrange() {
        for (int i = 0; i < 10; i++) {
            Log.d("TAG", "eatOrange is running");
            SystemClock.sleep(200);
        }
    }
}
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        thread1.start();
        thread2.start();
    }

    Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            Person.eatApple();
        }
    });

    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            Person.eatOrange();
        }
    });

}

執行結果：

12-15 09:09:24.378 31625-31912/com.example.shengqf.myapplication D/TAG: eatApple begin at:1513300164378
12-15 09:09:27.379 31625-31912/com.example.shengqf.myapplication D/TAG: eatApple end at:1513300167379
12-15 09:09:27.381 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:27.582 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:27.783 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:27.984 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:28.184 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:28.385 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:28.585 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:28.786 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:28.986 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:09:29.188 31625-31913/com.example.shengqf.myapplication D/TAG: eatOrange is running

現在將thread1和thread2程式碼改為：

Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            Person person1 = new Person();
            person1.eatApple();
        }
    });

    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            Person person2 = new Person();
            person2.eatOrange();
        }
    });

再執行結果：

12-15 09:12:38.316 32353-32378/com.example.shengqf.myapplication D/TAG: eatApple begin at:1513300358316
12-15 09:12:41.317 32353-32378/com.example.shengqf.myapplication D/TAG: eatApple end at:1513300361317
12-15 09:12:41.320 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:41.521 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:41.721 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:41.922 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:42.123 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:42.324 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:42.525 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:42.727 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:42.928 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running
12-15 09:12:43.129 32353-32379/com.example.shengqf.myapplication D/TAG: eatOrange is running

因為eatApple()和eatOrange()方法都是Person類裡的靜態方法，且被synchronized修飾，所以這兩個方法都是靠唯一的Person類鎖工作，所以無論是通過Person類名呼叫還是new不同的person物件呼叫，兩個方法都是互斥的。

結論：被synchronized 修飾的靜態方法要靠類鎖工作。當多執行緒同時訪問某個被synchronized修飾的靜態方法時，一旦某個程序搶得該類的類鎖之後，其他的程序只有排隊對待。

上面的Person程式碼等效於：

public class Person {

    public static void eatApple() {
        synchronized(Person.class){
            Log.d("TAG", "eatApple begin at:" + System.currentTimeMillis());
            SystemClock.sleep(3000);
            Log.d("TAG", "eatApple end at:" + System.currentTimeMillis());
        }
    }

    public static void eatOrange() {
        synchronized(Person.class){
            for (int i = 0; i < 10; i++) {
                Log.d("TAG", "eatOrange is running");
                SystemClock.sleep(200);
            }
        }
    }
}

相關推薦

淺析java中靜態方法，非靜態方法和構造方法的執行順序問題

https://blog.csdn.net/qq_42401622/article/details/81190406 對於java中的靜態方法，非靜態方法和構造方法的理解： 靜態方法是隨著的java中虛擬機器的類的載入而載入，是跟隨繫結在一起的。 public class Main{ s

JAVA 中 靜態方法，非靜態方法，構造方法 ，執行順序

一直不能理解java 中這三者的執行順序。@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);

synchronized修飾普通方法，修飾靜態方法，修飾代碼塊，修飾線程run方法 比較

共享數據 比較 art text run best 初始 一個 lol synchronized用於多線程設計，有了synchronized關鍵字，多線程程序的運行結果將變得可以控制。synchronized關鍵字用於保護共享數據。 synchronized實現同步的機制：

synchronized修飾普通方法，修飾靜態方法比較

一、synchronized修飾普通方法 初始化一個物件時，會自動生成一個與該物件對應的物件鎖，被synchronized 修飾的方法就得依靠物件鎖工作。當多執行緒同時訪問某個被synchronized修飾的方法時，一旦某個程序搶得物件鎖之後，其他的程序只有排隊對待。 例如，Pe

關於synchronized修飾靜態方法和非靜態方法

剛剛看了網上的一些資料，感覺講的不是很正確，網上說synchronized修飾靜態方法相當於加了把類鎖，所有該類的物件，都公用這把鎖，所以我寫了如下程式碼進行驗證： 如果按網上說 ，我用synchronized修飾靜態方法，那麼在啟動一個執行緒呼叫時，其他執行緒應該無法呼叫accessResou

使用synchronized修飾靜態方法和非靜態方法有什麼區別

前言 最近被問到了這個問題，第一次回答的也是很不好，在此參考網上答案進行整理記錄。供大家學習參考。 Synchronized修飾非靜態方法 Synchronized修飾非靜態方法，實際上是對呼叫該方法的物件加鎖，俗稱“物件鎖”。 Java中每個物件都有一個鎖，並且是唯一的。假設分配的一

當沒有繼承關係時，靜態塊、靜態方法、非靜態方法、構造方法、普通方法的執行順序

<span style="font-size:18px;">package test; /** * 不含有繼承時，各種方法（靜態塊，靜態方法，非靜態程式碼塊，構造方法，普通方法）的執行順序 * */ public class uExt

synchronized對普通同步方法和對靜態方法的區別

synchronized是一個重量級鎖,我們都知道該關鍵字鎖住的是物件而不是程式碼本身,那麼對於靜態方法和同步方法有什麼不同呢,通過如下程式碼進行測試 public class SynchronizedTest { private static int num; pri

"無法從靜態上下文中引用非靜態變量，非靜態方法"

使用 對象 上下文 類變量 static 非靜態變量 初始化 方法 log 原因:1.用static修飾的方法稱為靜態方法，修飾變量則為靜態變量，又分別叫做類方法或者類變量。 2.靜態的方法可以在沒有創建實例時使用,而申明為非靜態的成員變量是一個對象屬性,它只有在對象存在時

Java類的各種成員初始化順序如：父子類繼承時的靜態代碼塊,普通代碼塊,靜態方法,構造方法,等先後順

依次 成員初始化順序 main class 實例對象 變量 影響 {} 所在 class B extends A ,然後A類也就是父類裏面有靜態代碼塊，普通代碼塊，靜態方法，靜態成員變量，普通成員變量，普通方法。子類也是這樣，然後繼承之後，關於程序打印輸出的結果。涉及到Ja

Python：類屬性，實例屬性，私有屬性與靜態方法，類方法，實例方法

所有 參數 方法 rate self 類屬性 不能 anaconda 賦值 類屬性可以直接在方法中賦值，但 一、調用該屬性時，必須先調用該方法； 二、與 init 方法區別是，init方法只初始化一次，初始化完成後作為全局變量。在方法中賦值屬性，每次調用該方法，該屬性初始化

普通方法, 類方法 classmethod 與 靜態方法staticmethod 使用和區別.屬性函式property特性

普通方法, 類方法 classmethod  與 靜態方法staticmethod 使用和區別.屬性函式property特性 類方法: 使用時使用classmethod裝飾器裝飾的方法 優點: 簡潔的建立物件      

少說話多寫程式碼之Python學習050——類的成員（靜態方法，類成員方法，getattr，setattr）

我們在訪問類的欄位時，還有一些過濾的條件，類似於前端語言比如vue Js、anjularJs中過濾器的概念。在3.0以前可以使用比如，__setattr__，__getattr__的方法進行屬性的過濾。在3.0以後我們如果對某些欄位需要過濾訪問，也可以使用這些函式。 class Rectan

python靜態屬性@property、類方法@classmethod、靜態方法@staticmethod和普通方法

靜態屬性：即將類的函式通過@property屬性封裝，封裝後例項呼叫該函式時，不再需要在函式後面加()，而是用類似呼叫資料屬性的方式直接呼叫函式名稱即可執行函式。 靜態屬性既可以訪問類的屬性，也可以訪問例項的屬性。 類方法：即在類的函式前加@classmethod屬性，函式第一個引數為cls類，表示該函式

節省兩倍開發時間，Java靜態方法還可以這麼玩！

鏈式呼叫 首先需要提一下最近幾年在開發界大的鏈式呼叫，鏈式呼叫非常利於編寫，更利於閱讀，那麼，什麼是鏈式呼叫呢，為了掃盲，舉個例子。 栗子 示例程式碼如下，如果我們想建立一個Dialog，不依賴鏈式呼叫的話，將會產生如下程式碼：   上述程式碼共計372個字

Synchronized同步靜態方法和非靜態方法總結

1.Synchronized修飾非靜態方法，實際上是對呼叫該方法的物件加鎖，俗稱“物件鎖”。      Java中每個物件都有一個鎖，並且是唯一的。假設分配的一個物件空間，裡面有多個方法，相當於空間裡面有多個小房間，如果我們把所有的小房間都加鎖，因為這個物件只有一把鑰匙，因

python類例項方法，類方法和類靜態方法區別

類例項方法呼叫必須用例項, 類方法呼叫可以用例項也可以用類名, 類靜態方法調不需要例項化，通過類直接訪問 類方法的作用是它可以把例項當引數,也可以把類當引數傳進去 案例 class Person(): # 例項方法 def eat(self

使用Spring註解，在靜態方法中注入bean(spring靜態注入元件——工具類常用)

如果直接用spring注入靜態屬性，則會報錯，提示@Resource annotation is not supported on static fields，如果又一定要通過spring注入bean，可以採用@PostConstruct註解在某個用來初始化的方法上，注入時注

使用Spring註解，在靜態方法中注入bean

@Component public class FTPUtil { //通過dicService讀取資料庫中的FTP引數 @Autowired private DicService dicService; private static FTPUtil fTPUtil;

synchronized靜態方法與非靜態方法

    一個物件裡面如果有多個synchronized方法，某一個時刻內，只要一個執行緒去呼叫其中的一個synchronized方法了，其它的執行緒都只能等待，換句話說，某一個時刻內，只能有唯一一個執行緒去訪問這些synchronized。 我們需要先弄清楚synchron