一，介紹

本文介紹JAVA多執行緒中的synchronized關鍵字作為物件鎖的一些知識點。

所謂物件鎖，就是就是synchronized 給某個物件 加鎖。關於 物件鎖 可參考：這篇文章

二，分析

synchronized可以修飾例項方法，如下形式：

1 public class MyObject {
2 
3     synchronized public void methodA() {
4         //do something....
5     }

這裡，synchronized 關鍵字鎖住的是當前物件。這也是稱為物件鎖的原因。

為啥鎖住當前物件？因為 methodA()是個例項方法，要想執行methodA()，需要以 物件.方法() 的形式進行呼叫(obj.methodA()，obj是MyObject類的一個物件，synchronized就是把obj這個物件加鎖了)。

上面程式碼也可寫成這樣：

1 public class MyObject {
2 
3     public void methodA() {
4         synchronized(this){
5             //do something....
6         }
7     }

三，特點

使用synchronized關鍵字同步一個明顯的特點是：MyObject類中定義有多個synchronized修飾的例項方法時，若多個執行緒擁有同一個MyObject類的物件，則這些方法只能以同步的方式執行。即，執行完一個synchronized修飾的方法後，才能執行另一個synchronized修飾的方法。

如下：

 1 public class MyObject {
 2 
 3     synchronized public void methodA() {
 4         //do something....
 5     }
 6 
 7     synchronized public void methodB() {
 8         //do some other thing
 9     }
10 }

MyObject類中有兩個synchronized修飾的方法。

 1 public class ThreadA extends Thread {
 
 2 
 3     private MyObject object;
 4 //省略構造方法
 5     @Override
 6     public void run() {
 7         super.run();
 8         object.methodA();
 9     }
10 }

執行緒A執行methodA()

public class ThreadB extends Thread {

    private MyObject object;
//省略構造方法
    @Override
    public void run() {
        super.run();
        object.methodB();
    }
}

執行緒B執行methodB()

public class Run {
    public static void main(String[] args) {
        MyObject object = new MyObject();

        //執行緒A與執行緒B 持有的是同一個物件:object
        ThreadA a = new ThreadA(object);
        ThreadB b = new ThreadB(object);
        a.start();
        b.start();
    }
}

由於執行緒A和執行緒B持有同一個MyObject類的物件object，儘管這兩個執行緒需要呼叫不同的方法，但是必須是同步的，比如：執行緒B需要等待執行緒A執行完了methodA()方法之後，它才能執行methodB()方法。

四，結論

從上可以看出，本文中講述的 synchronized 鎖的範圍是整個物件。如果一個類中有多個synchronized修飾的同步方法，且多個執行緒持有該類的同一個物件（該類的相同的物件），儘管它們呼叫不同的方法，各個方法的執行也是同步的。

如果各個同步的方法之間沒有共享變數，或者說各個方法之間沒有聯絡，但也只能同步執行，這會影響效率。

五，應用--使用synchronized避免 因資料不一致性而導致讀髒資料的情況

如下示例：

 1 public class MyObject {
 2 
 3     private String userName = "b";
 4     private String passWord = "bb";
 5     
 6     synchronized public void methodA(String userName, String passWord) {
 7         this.userName = userName;
 8         try{
 9             Thread.sleep(5000);
10         }catch(InterruptedException e){
11             
12         }
13         this.passWord = passWord;
14     }
15 
16     synchronized public void methodB() {
17         System.out.println("userName" + userName + ": " + "passWord" + passWord);
18     }
19 }

methodA()負責更改使用者名稱和密碼。在現實中，一個使用者名稱對應著一個密碼。。。

methodB()負責讀取使用者名稱和密碼。

如果methodB()沒有用synchronized 修飾，執行緒A在呼叫methodA()執行到第7行，更改了使用者名稱，因某種原因（比如在第9行睡眠了）放棄了CPU。

此時，如果執行緒B去執行methodB()，那麼讀取到的使用者名稱是執行緒A更改了的使用者名稱("a")，但是密碼卻是原來的密碼("bb")。因為，執行緒A睡眠了，還沒有來得及更改密碼。

但是，如果methodB()用synchronized修飾，那麼執行緒B只能等待執行緒A執行完畢之後（即改了使用者名稱，也改了密碼），才能執行methodB讀取使用者名稱和密碼。因此，就避免了資料的不一致性而導致的髒讀問題。

其他參考資料：