最近工作有用到一些多執行緒的東西，之前吧，有用到synchronized同步塊，不過是別人怎麼用就跟著用，並沒有搞清楚鎖的概念。最近也是遇到一些問題，不搞清楚鎖的概念，很容易碰壁，甚至有些時候自己連用沒用對都不知道。

今天把一些疑惑都解開了，寫篇文章分享給大家，文章還算比較全面。當然可能有小寶鴿理解得不夠深入透徹的地方，如果說得不正確還望指出。

看之前有必要跟某些猿友說一下，如果看一遍沒有看明白呢，也沒關係，當是瞭解一下，等真正使用到了，再回頭看。

本文主要是將synchronized關鍵字用法作為例子來去解釋Java中的物件鎖和類鎖。特別的是希望能幫大家理清一些概念。

一、synchronized關鍵字

synchronized關鍵字有如下兩種用法：

1、 在需要同步的方法的方法簽名中加入synchronized關鍵字。

synchronized public void getValue() {
    System.out.println("getValue method thread name="
            + Thread.currentThread().getName() + " username=" + username
            + " password=" + password);
}

上面的程式碼修飾的synchronized是非靜態方法，如果修飾的是靜態方法（static）含義是完全不一樣的。具體不一樣在哪裡，後面會詳細說清楚。

synchronized static public void getValue() {
    System.out.println("getValue method thread name="
            + Thread.currentThread().getName() + " username=" + username
            + " password=" + password);
}

2、使用synchronized塊對需要進行同步的程式碼段進行同步。

public void serviceMethod() {
    try {
        synchronized (this
 
) {
            System.out.println("begin time=" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("end    end=" + System.currentTimeMillis());
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

上面的程式碼塊是synchronized (this)用法，還有synchronized (非this物件)以及synchronized (類.class)這兩種用法，這些使用方式的含義也是有根本的區別的。我們先帶著這些問題繼續往下看。

二、Java中的物件鎖和類鎖

小寶鴿似乎並沒有辦法用清晰簡短的語言來描述物件鎖和類鎖的概念。即便能用簡單的語句概況，也會顯得抽象。猿友們耐心看完自然會明白。

之前網上有找一些相關資料，有篇部落格是這樣描述的（看的是轉載的，原創連線我也不知道）：

一段synchronized的程式碼被一個執行緒執行之前，他要先拿到執行這段程式碼的許可權，
在Java裡邊就是拿到某個同步物件的鎖（一個物件只有一把鎖）；
如果這個時候同步物件的鎖被其他執行緒拿走了，他（這個執行緒）就只能等了（執行緒阻塞在鎖池等待佇列中）。 
取到鎖後，他就開始執行同步程式碼(被synchronized修飾的程式碼）；
執行緒執行完同步程式碼後馬上就把鎖還給同步物件，其他在鎖池中等待的某個執行緒就可以拿到鎖執行同步程式碼了。
這樣就保證了同步程式碼在統一時刻只有一個執行緒在執行。

上面提到鎖，這裡先引出鎖的概念。先來看看下面這些囉嗦而必不可少的文字。

多執行緒的執行緒同步機制實際上是靠鎖的概念來控制的。

在Java程式執行時環境中，JVM需要對兩類執行緒共享的資料進行協調：
1）儲存在堆中的例項變數
2）儲存在方法區中的類變數

這兩類資料是被所有執行緒共享的。
（程式不需要協調儲存在Java 棧當中的資料。因為這些資料是屬於擁有該棧的執行緒所私有的。）

這裡插播一下廣告：關於JVM記憶體，如果想了解可以看看博主的另外一篇文章：

方法區（Method Area）與Java堆一樣，是各個執行緒共享的記憶體區域，它用於儲存已被虛擬機器載入的類資訊、常量、靜態變數、即時編譯器編譯後的程式碼等資料。雖然Java虛擬機器規範把方法區描述為堆的一個邏輯部分，但是它卻有一個別名叫做Non-Heap（非堆），目的應該是與Java堆區分開來。

棧：在Java中，JVM中的棧記錄了執行緒的方法呼叫。每個執行緒擁有一個棧。在某個執行緒的執行過程中，如果有新的方法呼叫，那麼該執行緒對應的棧就會增加一個儲存單元，即幀(frame)。在frame中，儲存有該方法呼叫的引數、區域性變數和返回地址。

堆是JVM中一塊可自由分配給物件的區域。當我們談論垃圾回收(garbage collection)時，我們主要回收堆(heap)的空間。
Java的普通物件存活在堆中。與棧不同，堆的空間不會隨著方法呼叫結束而清空。因此，在某個方法中建立的物件，可以在方法呼叫結束之後，繼續存在於堆中。這帶來的一個問題是，如果我們不斷的建立新的物件，記憶體空間將最終消耗殆盡。

在java虛擬機器中，每個物件和類在邏輯上都是和一個監視器相關聯的。
對於物件來說，相關聯的監視器保護物件的例項變數。

對於類來說，監視器保護類的類變數。

（如果一個物件沒有例項變數，或者一個類沒有變數，相關聯的監視器就什麼也不監視。）
為了實現監視器的排他性監視能力，java虛擬機器為每一個物件和類都關聯一個鎖。代表任何時候只允許一個執行緒擁有的特權。執行緒訪問例項變數或者類變數不需鎖。

但是如果執行緒獲取了鎖，那麼在它釋放這個鎖之前，就沒有其他執行緒可以獲取同樣資料的鎖了。（鎖住一個物件就是獲取物件相關聯的監視器）

類鎖實際上用物件鎖來實現。當虛擬機器裝載一個class檔案的時候，它就會建立一個java.lang.Class類的例項。當鎖住一個物件的時候，實際上鎖住的是那個類的Class物件。

一個執行緒可以多次對同一個物件上鎖。對於每一個物件，java虛擬機器維護一個加鎖計數器，執行緒每獲得一次該物件，計數器就加1，每釋放一次，計數器就減 1，當計數器值為0時，鎖就被完全釋放了。

java程式設計人員不需要自己動手加鎖，物件鎖是java虛擬機器內部使用的。

在java程式中，只需要使用synchronized塊或者synchronized方法就可以標誌一個監視區域。當每次進入一個監視區域時，java 虛擬機器都會自動鎖上物件或者類。

三、synchronized關鍵字各種用法與例項

看完了”二、Java中的物件鎖和類鎖”，我們再來結合”一、synchronized關鍵字”裡面提到的synchronized用法。

事實上，synchronized修飾非靜態方法、同步程式碼塊的synchronized (this)用法和synchronized (非this物件)的用法鎖的是物件，執行緒想要執行對應同步程式碼，需要獲得物件鎖。

synchronized修飾靜態方法以及同步程式碼塊的synchronized (類.class)用法鎖的是類，執行緒想要執行對應同步程式碼，需要獲得類鎖。

因此，事實上synchronized關鍵字可以細分為上面描述的五種用法。

本文的例項均來自於《Java多執行緒程式設計核心技術》這本書裡面的例子。

1、我們先看看非執行緒安全例項（Run.java）：

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef);
        athread.start();

        ThreadB bthread = new ThreadB(numRef);
        bthread.start();

    }

}

class HasSelfPrivateNum {

    private int num = 0;

    public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}


class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }

}



 class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }

}

執行結果為：

a set over!
b set over!
b num=200
a num=200

修改HasSelfPrivateNum如下，方法用synchronized修飾如下：

class HasSelfPrivateNum {

    private int num = 0;

    synchronized public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

執行結果是執行緒安全的：

b set over!
b num=200
a set over!
a num=100

實驗結論：兩個執行緒訪問同一個物件中的同步方法是一定是執行緒安全的。本實現由於是同步訪問，所以先打印出a，然後打印出b

這裡執行緒獲取的是HasSelfPrivateNum的物件例項的鎖——物件鎖。

2、多個物件多個鎖

就上面的例項，我們將Run改成如下：

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef1);
        athread.start();

        ThreadB bthread = new ThreadB(numRef2);
        bthread.start();

    }

}

執行結果為：

a set over!
b set over!
b num=200
a num=200

這裡是非同步的，因為執行緒athread獲得是numRef1的物件鎖，而bthread執行緒獲取的是numRef2的物件鎖，他們並沒有在獲取鎖上有競爭關係，因此，出現非同步的結果

這裡插播一下：同步不具有繼承性

3、同步塊synchronized (this)

我們先看看程式碼例項（Run.java）

public class Run {

    public static void main(String[] args) {
        ObjectService service = new ObjectService();

        ThreadA a = new ThreadA(service);
        a.setName("a");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("b");
        b.start();
    }

}

class ObjectService {

    public void serviceMethod() {
        try {
            synchronized (this) {
                System.out.println("begin time=" + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


class ThreadA extends Thread {

    private ObjectService service;

    public ThreadA(ObjectService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.serviceMethod();
    }

}


class ThreadB extends Thread {
    private ObjectService service;

    public ThreadB(ObjectService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.serviceMethod();
    }
}

執行結果：

begin time=1466148260341
end    end=1466148262342
begin time=1466148262342
end    end=1466148264378

這樣也是同步的，執行緒獲取的是同步塊synchronized (this)括號（）裡面的物件例項的物件鎖，這裡就是ObjectService例項物件的物件鎖了。

需要注意的是synchronized (){}的{}前後的程式碼依舊是非同步的

4、synchronized (非this物件)

我們先看看程式碼例項（Run.java）

public class Run {

    public static void main(String[] args) {

        Service service = new Service("xiaobaoge");

        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();

    }

}

class Service {

    String anyString = new String();

    public Service(String anyString){
        this.anyString = anyString;
    }

    public void setUsernamePassword(String username, String password) {
        try {
            synchronized (anyString) {
                System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "進入同步塊");
                Thread.sleep(3000);
                System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "離開同步塊");
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.setUsernamePassword("a", "aa");

    }

}


class ThreadB extends Thread {

    private Service service;

    public ThreadB(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.setUsernamePassword("b", "bb");

    }

}

不難看出，這裡執行緒爭奪的是anyString的物件鎖，兩個執行緒有競爭同一物件鎖的關係，出現同步

現在有一個問題：一個類裡面有兩個非靜態同步方法，會有影響麼？

答案是：如果物件例項A，執行緒1獲得了物件A的物件鎖，那麼其他執行緒就不能進入需要獲得物件例項A的物件鎖才能訪問的同步程式碼（包括同步方法和同步塊）。不理解可以細細品味一下！

5、靜態synchronized同步方法

我們直接看程式碼例項：

public class Run {

    public static void main(String[] args) {

        ThreadA a = new ThreadA();
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB();
        b.setName("B");
        b.start();

    }

}

class Service {

    synchronized public static void printA() {
        try {
            System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "進入printA");
            Thread.sleep(3000);
            System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "離開printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        System.out.println("執行緒名稱為：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "進入printB");
        System.out.println("執行緒名稱為：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "離開printB");
    }

}


class ThreadA extends Thread {
    @Override
    public void run() {
        Service.printA();
    }

}


class ThreadB extends Thread {
    @Override
    public void run() {
        Service.printB();
    }
}

執行結果：

執行緒名稱為：A在1466149372909進入printA
執行緒名稱為：A在1466149375920離開printA
執行緒名稱為：B在1466149375920進入printB
執行緒名稱為：B在1466149375920離開printB

兩個執行緒在爭奪同一個類鎖，因此同步

6、synchronized (class)

對上面Service類程式碼修改成如下：

class Service {

    public static void printA() {
        synchronized (Service.class) {
            try {
                System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "進入printA");
                Thread.sleep(3000);
                System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "離開printA");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static void printB() {
        synchronized (Service.class) {
            System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "進入printB");
            System.out.println("執行緒名稱為：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "離開printB");
        }
    }
}

執行結果：

執行緒名稱為：A在1466149372909進入printA
執行緒名稱為：A在1466149375920離開printA
執行緒名稱為：B在1466149375920進入printB
執行緒名稱為：B在1466149375920離開printB

兩個執行緒依舊在爭奪同一個類鎖，因此同步

需要特別說明：對於同一個類A，執行緒1爭奪A物件例項的物件鎖，執行緒2爭奪類A的類鎖，這兩者不存在競爭關係。也就說物件鎖和類鎖互補干預內政

靜態方法則一定會同步，非靜態方法需在單例模式才生效，但是也不能都用靜態同步方法，總之用得不好可能會給效能帶來極大的影響。另外，有必要說一下的是Spring的bean預設是單例的。