Synchronized關鍵字的使用

前面介紹了多執行緒的諸多優點，好用歸好用，同時也出現了一個問題就是執行緒的同步。當不做執行緒的同步控制，多個執行緒跑起來並對一個共享變數做改動，執行完畢後，你會發現共享變數的值不如你願。因為這些執行緒沒能實現執行緒安全。關於執行緒安全和執行緒非安全，看下百度的解釋：

執行緒安全&執行緒非安全

執行緒安全就是多執行緒訪問時，採用了加鎖機制，當一個執行緒訪問該類的某個資料時，進行保護，其他執行緒不能進行訪問直到該執行緒讀取完，其他執行緒才可使用。不會出現資料不一致或者資料汙染。 執行緒不安全就是不提供資料訪問保護，有可能出現多個執行緒先後更改資料造成所得到的資料是髒資料。

保證執行緒安全，java提供了以下幾種同步策略：

1. synchronized關鍵字。
2. volatile關鍵字。
3. JUC包中的Lock介面。
   4.ThreadLocal管理變數。
   本篇主要介紹一下synchronized關鍵字的使用。
   通俗點描述synchronized，它就像是掛在一個衣櫃上的鎖。記得大學和兄弟們打完球，一起去澡堂沖涼，走進更衣室，會看見有很多衣櫃，一個個衣櫃就如同一個個共享變數，如果一個衣櫃上有鎖（synchronized）,說明這個櫃（共享變數）正在被人（執行緒）使用，你如果非要用這個櫃子，就得等正在使用這個櫃子的人用完櫃子，釋放了鎖，你再使用。
   先示範一把執行緒非安全的例子：

public class Test5 implements Runnable {
    private  int count = 0;
    @Override
    public void run() {
        for(int i = 0; i < 8; i++){
            System.out.println(Thread.currentThread().getName()+ ":" + count++);
        }
    }
    public static void main(String[] args) {
        Test5 test5 = new Test5();
        Thread thread1 = new Thread(test5,"thread1");
        Thread thread2 = new Thread(test5,"thread2");
        thread1.start();
        thread2.start();
    }
}

執行結果：（本想著count值為15，執行結果卻是14，且thread1和thread2交叉著修改著count）

synchronized修飾一個方法

如果想讓上面例子執行緒安全，且最後的count為15,使用synchronized修飾方法。修改上述程式碼的run()方法,兩種寫法：
①直接在方法訪問修飾符後面加synchronized

@Override
public synchronized void run() {
    for(int i = 0; i < 8; i++){
        System.out.println(Thread.currentThread().getName()+ ":" + count++);
    }
 }

②在方法內部使用synchronized修飾方法程式碼塊

@Override
public void run() {
     synchronized (this){
         for(int i = 0; i < 8; i++){
             System.out.println(Thread.currentThread().getName()+ ":" + count++);
         }
     }
}

兩種結果的執行結果是一致的，可以看出：當兩個執行緒訪問同一個物件（test5）的synchronized方法時，同一時刻只能有一個執行緒執行，另一個阻塞，兩個執行緒是互斥的，只有當第一個執行完畢釋放了鎖，第二個執行緒才能獲取鎖重新鎖定物件。

繼續玩Test5，將其main方法內部做下修改，修改如下：

public static void main(String[] args) {
     Thread thread1 = new Thread(new Test5(),"thread1");
     Thread thread2 = new Thread(new Test5(),"thread2");
     thread1.start();
     thread2.start();
}

執行結果如下：

這是怎麼回事，不是已經用synchronized修飾了run()，鎖定物件了嗎，怎麼兩個執行緒交叉執行，且count都是7,難道使用的姿勢不對？？？

原因：synchronized鎖定的是物件，new Test5()兩次會建立兩個獨立的物件，所以會有兩把鎖鎖定兩個物件，thread1執行著物件1的run()，thread2執行著物件2的run(),所以兩個執行緒互不影響，各執行各的。

synchronized(this)，this為何物？

public class Test5 implements Runnable {
    private static int count = 0;
    @Override
    public void run() {
        synchronized (this){
            for(int i = 0; i < 8; i++){
                System.out.println(Thread.currentThread().getName()+ ":" + count++);
            }
        }
    }
    public static void main(String[] args) {
        Test5 test5 = new Test5();
        Thread thread1 = new Thread(test5,"thread1");
        Thread thread2 = new Thread(test5,"thread2");
        thread1.start();
        thread2.start();
    }
}

執行結果（執行緒安全）：

修改main方法如下:

public static void main(String[] args) {
        Thread thread1 = new Thread(new Test5(),"thread1");
        Thread thread2 = new Thread(new Test5(),"thread2");
        thread1.start();
        thread2.start();
}

從這個例子就可以看出：這裡的this是指當前物件,不管是物件A還是物件B，剛開始執行這段程式碼的時候會給這段程式碼加個鎖,這樣即使執行到中間被替換了,另一個執行緒也不會執行這段程式碼,因為這段程式碼加鎖了,而鑰匙在給程式碼加鎖的那個執行緒手裡,只有加鎖的執行緒執行完這段程式碼,才會給程式碼解鎖.然後其他執行緒才能執行這段程式碼。

修飾一個靜態方法

靜態方法是屬於整個類的，所以synchronized修飾靜態方法鎖定的就是這個類的所有物件。

public class Test5 implements Runnable {
    private static int count = 0;
    @Override
    public void run() {
        addCount();
    }
    public static synchronized void addCount(){
        for(int i = 0; i < 8; i++){
            System.out.println(Thread.currentThread().getName()+ ":" + count++);
        }
    }
    public static void main(String[] args) {
        Test5 test5 = new Test5();
        Thread thread1 = new Thread(test5,"thread1");
        Thread thread2 = new Thread(test5,"thread2");
        thread1.start();
        thread2.start();
    }
}

執行結果：

修改Test5的main(),再次執行

public static void main(String[] args) {
        Thread thread1 = new Thread(new Test5(),"thread1");
        Thread thread2 = new Thread(new Test5(),"thread2");
        thread1.start();
        thread2.start();
}

可以發現執行結果還是上圖，new Test5()建立了兩個不同的物件，但thread1、thread2的執行確實執行緒安全的，原因是synchronized修飾的是靜態方法，靜態方法是屬於類的，兩個物件用的是同一個鎖，所以同步。

修飾一個類

修改Test5的addCount()方法，修改如下：

public static void addCount(){
    synchronized (Test5.class){
        for(int i = 0; i < 8; i++){
            System.out.println(Thread.currentThread().getName()+ ":" + count++);
        }
    }
}

執行結果（執行緒安全的）：

synchronized不支援繼承

synchronized可以修飾方法，但不屬於方法定義的一部分，不能夠被繼承。如果父類的一個方法使用了synchronized，子類中重寫了此方法，那麼在子類中的這個方法預設是不同步的。如果要達到同步效果，一是在子類方法前也加上synchronized,二是在子類方法中呼叫父類的同步方法。

總結

synchronized是java中的關鍵字，是種同步鎖。
①對於同步的方法或程式碼塊，要先獲得物件鎖才能進入同步方法或程式碼塊進行操作;
②synchronized可修飾方法，分為靜態方法和非靜態方法，修飾靜態方法鎖定的是整個類，修飾非靜態方法鎖定的是一個物件;
③synchronized可修飾類，修飾的是這個類的所有物件；
④程式碼塊synchronized(a)，物件鎖就是a。
⑤synchronized修飾方法不支援繼承。

略陳固陋，如有不當之處，歡迎各位看官批評指正！