Java 之 synchronized 詳解

1、概念

synchronized 是 Java 中的關鍵字，是利用鎖的機制來實現同步的。

鎖機制有以下兩種特性：

• 互斥性：即在同一時間只容許一個線程持有某個對象鎖，經過這種特性來實現多線程中的協調機制，這樣在同一時間只有一個線程對需同步的代碼塊(複合操做)進行訪問。互斥性咱們也每每稱爲操做的原子性。

• 可見性：必須確保在鎖被釋放以前，對共享變量所作的修改，對於隨後得到該鎖的另外一個線程是可見的（即在得到鎖時應得到最新共享變量的值），不然另外一個線程多是在本地緩存的某個副本上繼續操做從而引發不一致。

2、對象鎖和類鎖

1. 對象鎖

在 Java 中，每一個對象都會有一個 monitor 對象，這個對象其實就是 Java 對象的鎖，一般會被稱爲「內置鎖」或「對象鎖」。類的對象能夠有多個，因此每一個對象有其獨立的對象鎖，互不干擾。

2. 類鎖

在 Java 中，針對每一個類也有一個鎖，能夠稱爲「類鎖」，類鎖其實是經過對象鎖實現的，即類的 Class 對象鎖。每一個類只有一個 Class 對象，因此每一個類只有一個類鎖。

3、synchronized 的用法分類

synchronized 的用法能夠從兩個維度上面分類：

1. 根據修飾對象分類

synchronized 能夠修飾方法和代碼塊

• 修飾代碼塊

  • synchronized(this|object) {}

  • synchronized(類.class) {}

• 修飾方法

  • 修飾非靜態方法

  • 修飾靜態方法

2. 根據獲取的鎖分類

• 獲取對象鎖

  • synchronized(this|object) {}

  • 修飾非靜態方法

• 獲取類鎖

  • synchronized(類.class) {}

  • 修飾靜態方法

4、synchronized 的用法詳解

這裏根據獲取的鎖分類來分析 synchronized 的用法

1. 獲取對象鎖

1.1 對於同一對象

• 同步線程類：

class SyncThread implements Runnable {

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.startsWith("A")) {
            async();
        } else if (threadName.startsWith("B")) {
            sync1();
        } else if (threadName.startsWith("C")) {
            sync2();
        }

    }

    /**
     * 異步方法
     */
    private void async() {
        try {
            System.out.println(Thread.currentThread().getName() + "_Async_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Async_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 方法中有 synchronized(this|object) {} 同步代碼塊
     */
    private void sync1() {
        System.out.println(Thread.currentThread().getName() + "_Sync1: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + "_Sync1_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "_Sync1_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * synchronized 修飾非靜態方法
     */
    private synchronized void sync2() {
        System.out.println(Thread.currentThread().getName() + "_Sync2: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync2_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync2_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}複製代碼

• 測試代碼：

public class SyncTest {

    public static void main(String... args) {
        SyncThread syncThread = new SyncThread();
        Thread A_thread1 = new Thread(syncThread, "A_thread1");
        Thread A_thread2 = new Thread(syncThread, "A_thread2");
        Thread B_thread1 = new Thread(syncThread, "B_thread1");
        Thread B_thread2 = new Thread(syncThread, "B_thread2");
        Thread C_thread1 = new Thread(syncThread, "C_thread1");
        Thread C_thread2 = new Thread(syncThread, "C_thread2");
        A_thread1.start();
        A_thread2.start();
        B_thread1.start();
        B_thread2.start();
        C_thread1.start();
        C_thread2.start();
    }
}複製代碼

• 運行結果：

B_thread2_Sync1: 14:44:20
A_thread1_Async_Start: 14:44:20
B_thread1_Sync1: 14:44:20
C_thread1_Sync2: 14:44:20
A_thread2_Async_Start: 14:44:20
C_thread1_Sync2_Start: 14:44:20
A_thread1_Async_End: 14:44:22
A_thread2_Async_End: 14:44:22
C_thread1_Sync2_End: 14:44:22
B_thread1_Sync1_Start: 14:44:22
B_thread1_Sync1_End: 14:44:24
B_thread2_Sync1_Start: 14:44:24
B_thread2_Sync1_End: 14:44:26
C_thread2_Sync2: 14:44:26
C_thread2_Sync2_Start: 14:44:26
C_thread2_Sync2_End: 14:44:28複製代碼

• 結果分析：

  • A 類線程訪問方法中沒有同步代碼塊，A 類線程是異步的，因此有線程訪問對象的同步代碼塊時，另外的線程能夠訪問該對象的非同步代碼塊：

    A_thread1_Async_Start: 14:44:20
    A_thread2_Async_Start: 14:44:20
    A_thread1_Async_End: 14:44:22
    A_thread2_Async_End: 14:44:22複製代碼

  • B 類線程訪問的方法中有同步代碼塊，B 類線程是同步的，一個線程在訪問對象的同步代碼塊，另外一個訪問對象的同步代碼塊的線程會被阻塞：

    B_thread1_Sync1_Start: 14:44:22
    B_thread1_Sync1_End: 14:44:24
    B_thread2_Sync1_Start: 14:44:24
    B_thread2_Sync1_End: 14:44:26複製代碼

  • synchronized(this|object) {} 代碼塊 {} 以外的代碼依然是異步的：

    B_thread2_Sync1: 14:44:20
    B_thread1_Sync1: 14:44:20複製代碼

  • C 類線程訪問的是 synchronized 修飾非靜態方法，C 類線程是同步的，一個線程在訪問對象的同步代方法，另外一個訪問對象同步方法的線程會被阻塞：

    C_thread1_Sync2_Start: 14:44:20
    C_thread1_Sync2_End: 14:44:22
    C_thread2_Sync2_Start: 14:44:26
    C_thread2_Sync2_End: 14:44:28複製代碼

  • synchronized 修飾非靜態方法，做用範圍是整個方法，因此方法中全部的代碼都是同步的：

    C_thread1_Sync2: 14:44:20
    C_thread2_Sync2: 14:44:26複製代碼

  • 由結果可知 B 類和 C 類線程順序執行，**類中 synchronized(this|object) {} 代碼塊和 synchronized 修飾非靜態方法獲取的鎖是同一個鎖，即該類的對象的對象鎖。**因此 B 類線程和 C 類線程也是同步的：

    B_thread1_Sync1_Start: 14:44:22
    B_thread1_Sync1_End: 14:44:24
    C_thread1_Sync2_Start: 14:44:20
    C_thread1_Sync2_End: 14:44:22
    B_thread2_Sync1_Start: 14:44:24
    B_thread2_Sync1_End: 14:44:26
    C_thread2_Sync2_Start: 14:44:26
    C_thread2_Sync2_End: 14:44:28複製代碼

1.2 對於不一樣對象

• 修改測試代碼爲：

public class SyncTest {

    public static void main(String... args) {
        Thread A_thread1 = new Thread(new SyncThread(), "A_thread1");
        Thread A_thread2 = new Thread(new SyncThread(), "A_thread2");
        Thread B_thread1 = new Thread(new SyncThread(), "B_thread1");
        Thread B_thread2 = new Thread(new SyncThread(), "B_thread2");
        Thread C_thread1 = new Thread(new SyncThread(), "C_thread1");
        Thread C_thread2 = new Thread(new SyncThread(), "C_thread2");
        A_thread1.start();
        A_thread2.start();
        B_thread1.start();
        B_thread2.start();
        C_thread1.start();
        C_thread2.start();
    }
}複製代碼

• 運行結果：

A_thread2_Async_Start: 15:01:34
C_thread2_Sync2: 15:01:34
B_thread2_Sync1: 15:01:34
C_thread1_Sync2: 15:01:34
B_thread2_Sync1_Start: 15:01:34
B_thread1_Sync1: 15:01:34
C_thread1_Sync2_Start: 15:01:34
A_thread1_Async_Start: 15:01:34
C_thread2_Sync2_Start: 15:01:34
B_thread1_Sync1_Start: 15:01:34
C_thread1_Sync2_End: 15:01:36
A_thread1_Async_End: 15:01:36
C_thread2_Sync2_End: 15:01:36
B_thread2_Sync1_End: 15:01:36
B_thread1_Sync1_End: 15:01:36
A_thread2_Async_End: 15:01:36複製代碼

• 結果分析：

  • 兩個線程訪問不一樣對象的 synchronized(this|object) {} 代碼塊和 synchronized 修飾非靜態方法是異步的，同一個類的不一樣對象的對象鎖互不干擾。

2 獲取類鎖

2.1 對於同一對象

• 同步線程類：

class SyncThread implements Runnable {

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.startsWith("A")) {
            async();
        } else if (threadName.startsWith("B")) {
            sync1();
        } else if (threadName.startsWith("C")) {
            sync2();
        }

    }

    /**
     * 異步方法
     */
    private void async() {
        try {
            System.out.println(Thread.currentThread().getName() + "_Async_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Async_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 方法中有 synchronized(類.class) {} 同步代碼塊
     */
    private void sync1() {
        System.out.println(Thread.currentThread().getName() + "_Sync1: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        synchronized (SyncThread.class) {
            try {
                System.out.println(Thread.currentThread().getName() + "_Sync1_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "_Sync1_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * synchronized 修飾靜態方法
     */
    private synchronized static void sync2() {
        System.out.println(Thread.currentThread().getName() + "_Sync2: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync2_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync2_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}複製代碼

• 測試代碼：

public class SyncTest {

    public static void main(String... args) {
        SyncThread syncThread = new SyncThread();
        Thread A_thread1 = new Thread(syncThread, "A_thread1");
        Thread A_thread2 = new Thread(syncThread, "A_thread2");
        Thread B_thread1 = new Thread(syncThread, "B_thread1");
        Thread B_thread2 = new Thread(syncThread, "B_thread2");
        Thread C_thread1 = new Thread(syncThread, "C_thread1");
        Thread C_thread2 = new Thread(syncThread, "C_thread2");
        A_thread1.start();
        A_thread2.start();
        B_thread1.start();
        B_thread2.start();
        C_thread1.start();
        C_thread2.start();
    }
}複製代碼

• 運行結果：

B_thread1_Sync1: 15:08:13
C_thread1_Sync2: 15:08:13
B_thread2_Sync1: 15:08:13
A_thread1_Async_Start: 15:08:13
C_thread1_Sync2_Start: 15:08:13
A_thread2_Async_Start: 15:08:13
C_thread1_Sync2_End: 15:08:15
A_thread2_Async_End: 15:08:15
A_thread1_Async_End: 15:08:15
B_thread2_Sync1_Start: 15:08:15
B_thread2_Sync1_End: 15:08:17
B_thread1_Sync1_Start: 15:08:17
B_thread1_Sync1_End: 15:08:19
C_thread2_Sync2: 15:08:19
C_thread2_Sync2_Start: 15:08:19
C_thread2_Sync2_End: 15:08:21複製代碼

• 結果分析：

  • 由結果能夠看出，在同一對象的狀況下，synchronized(類.class) {} 代碼塊或 synchronized 修飾靜態方法和 synchronized(this|object) {} 代碼塊和 synchronized 修飾非靜態方法的行爲一致。

2.2 對於不一樣對象

• 修改測試代碼爲：

public class SyncTest {

    public static void main(String... args) {
        Thread A_thread1 = new Thread(new SyncThread(), "A_thread1");
        Thread A_thread2 = new Thread(new SyncThread(), "A_thread2");
        Thread B_thread1 = new Thread(new SyncThread(), "B_thread1");
        Thread B_thread2 = new Thread(new SyncThread(), "B_thread2");
        Thread C_thread1 = new Thread(new SyncThread(), "C_thread1");
        Thread C_thread2 = new Thread(new SyncThread(), "C_thread2");
        A_thread1.start();
        A_thread2.start();
        B_thread1.start();
        B_thread2.start();
        C_thread1.start();
        C_thread2.start();
    }
}複製代碼

• 運行結果：

A_thread2_Async_Start: 15:17:28
B_thread2_Sync1: 15:17:28
A_thread1_Async_Start: 15:17:28
B_thread1_Sync1: 15:17:28
C_thread1_Sync2: 15:17:28
C_thread1_Sync2_Start: 15:17:28
C_thread1_Sync2_End: 15:17:30
A_thread2_Async_End: 15:17:30
B_thread1_Sync1_Start: 15:17:30
A_thread1_Async_End: 15:17:30
B_thread1_Sync1_End: 15:17:32
B_thread2_Sync1_Start: 15:17:32
B_thread2_Sync1_End: 15:17:34
C_thread2_Sync2: 15:17:34
C_thread2_Sync2_Start: 15:17:34
C_thread2_Sync2_End: 15:17:36複製代碼

• 結果分析：

  • 兩個線程訪問不一樣對象的 synchronized(類.class) {} 代碼塊或 synchronized 修飾靜態方法仍是同步的，類中 synchronized(類.class) {} 代碼塊和 synchronized 修飾靜態方法獲取的鎖是類鎖。對於同一個類的不一樣對象的類鎖是同一個。

3 類中同時有 synchronized(類.class) {} 代碼塊或 synchronized 修飾靜態方法和 synchronized(this|object) {} 代碼塊和 synchronized 修飾非靜態方法時會怎樣？

• 修改同步線程類：

class SyncThread implements Runnable {

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.startsWith("A")) {
            async();
        } else if (threadName.startsWith("B")) {
            sync1();
        } else if (threadName.startsWith("C")) {
            sync2();
        }

    }

    /**
     * 異步方法
     */
    private void async() {
        try {
            System.out.println(Thread.currentThread().getName() + "_Async_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Async_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * synchronized 修飾非靜態方法
     */
    private synchronized void sync1() {
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync1_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync1_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * synchronized 修飾靜態方法
     */
    private synchronized static void sync2() {
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync2_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync2_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}複製代碼

• 修改測試代碼：

public class SyncTest {

    public static void main(String... args) {
        Thread B_thread1 = new Thread(syncThread, "B_thread1");
        Thread C_thread1 = new Thread(syncThread, "C_thread1");
        B_thread1.start();
        C_thread1.start();
    }
}複製代碼

• 運行結果：

B_thread1_Sync1_Start: 15:35:21
C_thread1_Sync2_Start: 15:35:21
B_thread1_Sync1_End: 15:35:23
C_thread1_Sync2_End: 15:35:23複製代碼

• 運行結果分析：

  • 由結果能夠看到 B 類線程和 C 類線程是異步的，即 synchronized 修飾靜態方法和 synchronized 修飾非靜態方法是異步的，對於 synchronized(類.class) {} 代碼塊和 synchronized(this|object) {} 代碼塊也是同樣的。因此對象鎖和類鎖是獨立的，互不干擾。

4 補充

1. synchronized關鍵字不能繼承。

   對於父類中的 synchronized 修飾方法，子類在覆蓋該方法時，默認狀況下不是同步的，必須顯示的使用 synchronized 關鍵字修飾才行。

2. 在定義接口方法時不能使用synchronized關鍵字。

3. 構造方法不能使用synchronized關鍵字，但可使用synchronized代碼塊來進行同步。

5.原理

探索synchronized的實現機制、Java是如何對它進行了優化、鎖優化機制、鎖的存儲結構和升級過程；

當一個線程訪問同步代碼塊時，它首先是須要獲得鎖才能執行同步代碼，當退出或者拋出異常時必需要釋放鎖，那麼它是如何來實現這個機制的呢？咱們先看一段簡單的代碼：

public class SynchronizedTest {
    public synchronized void test1(){

    }

    public void test2(){
        synchronized (this){

        }
    }
}
 

利用javap工具查看生成的class文件信息來分析Synchronize的實現

從上面能夠看出，同步代碼塊是使用monitorenter和monitorexit指令實現的，同步方法（在這看不出來須要看JVM底層實現）依靠的是方法修飾符上的ACC_SYNCHRONIZED實現。
同步代碼塊：monitorenter指令插入到同步代碼塊的開始位置，monitorexit指令插入到同步代碼塊的結束位置，JVM須要保證每個monitorenter都有一個monitorexit與之相對應。任何對象都有一個monitor與之相關聯，當且一個monitor被持有以後，他將處於鎖定狀態。線程執行到monitorenter指令時，將會嘗試獲取對象所對應的monitor全部權，即嘗試獲取對象的鎖；
同步方法：synchronized方法則會被翻譯成普通的方法調用和返回指令如:invokevirtual、areturn指令，在VM字節碼層面並無任何特別的指令來實現被synchronized修飾的方法，而是在Class文件的方法表中將該方法的access_flags字段中的synchronized標誌位置1，表示該方法是同步方法並使用調用該方法的對象或該方法所屬的Class在JVM的內部對象表示Klass作爲鎖對象。(摘自：http://www.cnblogs.com/javaminer/p/3889023.html)
原文連接：https://blog.csdn.net/chenssy/article/details/54883355

下面咱們來繼續分析，可是在深刻以前咱們須要瞭解兩個重要的概念：Java對象頭，Monitor。

Java對象頭、monitor
Java對象頭和monitor是實現synchronized的基礎！下面就這兩個概念來作詳細介紹。

Java對象頭
synchronized用的鎖是存在Java對象頭裏的，那麼什麼是Java對象頭呢？Hotspot虛擬機的對象頭主要包括兩部分數據：Mark Word（標記字段）、Klass Pointer（類型指針）。其中Klass Point是是對象指向它的類元數據的指針，虛擬機經過這個指針來肯定這個對象是哪一個類的實例，Mark Word用於存儲對象自身的運行時數據，它是實現輕量級鎖和偏向鎖的關鍵，因此下面將重點闡述

Mark Word。
Mark Word用於存儲對象自身的運行時數據，如哈希碼（HashCode）、GC分代年齡、鎖狀態標誌、線程持有的鎖、偏向線程 ID、偏向時間戳等等。Java對象頭通常佔有兩個機器碼（在32位虛擬機中，1個機器碼等於4字節，也就是32bit），可是若是對象是數組類型，則須要三個機器碼，由於JVM虛擬機能夠經過Java對象的元數據信息肯定Java對象的大小，可是沒法從數組的元數據來確認數組的大小，因此用一塊來記錄數組長度。下圖是Java對象頭的存儲結構（32位虛擬機）：

對象頭信息是與對象自身定義的數據無關的額外存儲成本，可是考慮到虛擬機的空間效率，Mark Word被設計成一個非固定的數據結構以便在極小的空間內存存儲儘可能多的數據，它會根據對象的狀態複用本身的存儲空間，也就是說，Mark Word會隨着程序的運行發生變化，變化狀態以下（32位虛擬機）：

簡單介紹了Java對象頭，咱們下面再看Monitor。

Monitor
什麼是Monitor？咱們能夠把它理解爲一個同步工具，也能夠描述爲一種同步機制，它一般被描述爲一個對象。
與一切皆對象同樣，全部的Java對象是天生的Monitor，每個Java對象都有成爲Monitor的潛質，由於在Java的設計中 ，每個Java對象自打孃胎裏出來就帶了一把看不見的鎖，它叫作內部鎖或者Monitor鎖。
Monitor 是線程私有的數據結構，每個線程都有一個可用monitor record列表，同時還有一個全局的可用列表。每個被鎖住的對象都會和一個monitor關聯（對象頭的MarkWord中的LockWord指向monitor的起始地址），同時monitor中有一個Owner字段存放擁有該鎖的線程的惟一標識，表示該鎖被這個線程佔用。其結構以下：

Owner：初始時爲NULL表示當前沒有任何線程擁有該monitor record，當線程成功擁有該鎖後保存線程惟一標識，當鎖被釋放時又設置爲NULL；
EntryQ:關聯一個系統互斥鎖（semaphore），阻塞全部試圖鎖住monitor record失敗的線程。
RcThis:表示blocked或waiting在該monitor record上的全部線程的個數。
Nest:用來實現重入鎖的計數。
HashCode:保存從對象頭拷貝過來的HashCode值（可能還包含GC age）。
Candidate:用來避免沒必要要的阻塞或等待線程喚醒，由於每一次只有一個線程可以成功擁有鎖，若是每次前一個釋放鎖的線程喚醒全部正在阻塞或等待的線程，會引發沒必要要的上下文切換（從阻塞到就緒而後由於競爭鎖失敗又被阻塞）從而致使性能嚴重降低。Candidate只有兩種可能的值0表示沒有須要喚醒的線程1表示要喚醒一個繼任線程來競爭鎖。
摘自：Java中synchronized的實現原理與應用）
咱們知道synchronized是重量級鎖，效率不怎麼滴，同時這個觀念也一直存在咱們腦海裏，不過在jdk 1.6中對synchronize的實現進行了各類優化，使得它顯得不是那麼重了，那麼JVM採用了那些優化手段呢？

鎖優化
jdk1.6對鎖的實現引入了大量的優化，如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減小鎖操做的開銷。
鎖主要存在四中狀態，依次是：無鎖狀態、偏向鎖狀態、輕量級鎖狀態、重量級鎖狀態，他們會隨着競爭的激烈而逐漸升級。注意鎖能夠升級不可降級，這種策略是爲了提升得到鎖和釋放鎖的效率。

自旋鎖
線程的阻塞和喚醒須要CPU從用戶態轉爲核心態，頻繁的阻塞和喚醒對CPU來講是一件負擔很重的工做，勢必會給系統的併發性能帶來很大的壓力。同時咱們發如今許多應用上面，對象鎖的鎖狀態只會持續很短一段時間，爲了這一段很短的時間頻繁地阻塞和喚醒線程是很是不值得的。因此引入自旋鎖。
何謂自旋鎖？
所謂自旋鎖，就是讓該線程等待一段時間，不會被當即掛起，看持有鎖的線程是否會很快釋放鎖。怎麼等待呢？執行一段無心義的循環便可（自旋）。
自旋等待不能替代阻塞，先不說對處理器數量的要求（多核，貌似如今沒有單核的處理器了），雖然它能夠避免線程切換帶來的開銷，可是它佔用了處理器的時間。若是持有鎖的線程很快就釋放了鎖，那麼自旋的效率就很是好，反之，自旋的線程就會白白消耗掉處理的資源，它不會作任何有意義的工做，典型的佔着茅坑不拉屎，這樣反而會帶來性能上的浪費。因此說，自旋等待的時間（自旋的次數）必需要有一個限度，若是自旋超過了定義的時間仍然沒有獲取到鎖，則應該被掛起。
自旋鎖在JDK 1.4.2中引入，默認關閉，可是可使用-XX:+UseSpinning開開啓，在JDK1.6中默認開啓。同時自旋的默認次數爲10次，能夠經過參數-XX:PreBlockSpin來調整；
若是經過參數-XX:preBlockSpin來調整自旋鎖的自旋次數，會帶來諸多不便。假如我將參數調整爲10，可是系統不少線程都是等你剛剛退出的時候就釋放了鎖（假如你多自旋一兩次就能夠獲取鎖），你是否是很尷尬。因而JDK1.6引入自適應的自旋鎖，讓虛擬機會變得愈來愈聰明。

適應自旋鎖
JDK 1.6引入了更加聰明的自旋鎖，即自適應自旋鎖。所謂自適應就意味着自旋的次數再也不是固定的，它是由前一次在同一個鎖上的自旋時間及鎖的擁有者的狀態來決定。它怎麼作呢？線程若是自旋成功了，那麼下次自旋的次數會更加多，由於虛擬機認爲既然上次成功了，那麼這次自旋也頗有可能會再次成功，那麼它就會容許自旋等待持續的次數更多。反之，若是對於某個鎖，不多有自旋可以成功的，那麼在之後要或者這個鎖的時候自旋的次數會減小甚至省略掉自旋過程，以避免浪費處理器資源。
有了自適應自旋鎖，隨着程序運行和性能監控信息的不斷完善，虛擬機對程序鎖的情況預測會愈來愈準確，虛擬機會變得愈來愈聰明。

鎖消除
爲了保證數據的完整性，咱們在進行操做時須要對這部分操做進行同步控制，可是在有些狀況下，JVM檢測到不可能存在共享數據競爭，這是JVM會對這些同步鎖進行鎖消除。鎖消除的依據是逃逸分析的數據支持。
若是不存在競爭，爲何還須要加鎖呢？因此鎖消除能夠節省毫無心義的請求鎖的時間。變量是否逃逸，對於虛擬機來講須要使用數據流分析來肯定，可是對於咱們程序員來講這還不清楚麼？咱們會在明明知道不存在數據競爭的代碼塊前加上同步嗎？可是有時候程序並非咱們所想的那樣？咱們雖然沒有顯示使用鎖，可是咱們在使用一些JDK的內置API時，如StringBuffer、Vector、HashTable等，這個時候會存在隱形的加鎖操做。好比StringBuffer的append()方法，Vector的add()方法：

    public void vectorTest(){
        Vector<String> vector = new Vector<String>();
        for(int i = 0 ; i < 10 ; i++){
            vector.add(i + "");
        }

        System.out.println(vector);
    }

在運行這段代碼時，JVM能夠明顯檢測到變量vector沒有逃逸出方法vectorTest()以外，因此JVM能夠大膽地將vector內部的加鎖操做消除。

鎖粗化
咱們知道在使用同步鎖的時候，須要讓同步塊的做用範圍儘量小—僅在共享數據的實際做用域中才進行同步，這樣作的目的是爲了使須要同步的操做數量儘量縮小，若是存在鎖競爭，那麼等待鎖的線程也能儘快拿到鎖。
在大多數的狀況下，上述觀點是正確的，LZ也一直堅持着這個觀點。可是若是一系列的連續加鎖解鎖操做，可能會致使沒必要要的性能損耗，因此引入鎖粗話的概念。
鎖粗話概念比較好理解，就是將多個連續的加鎖、解鎖操做鏈接在一塊兒，擴展成一個範圍更大的鎖。如上面實例：vector每次add的時候都須要加鎖操做，JVM檢測到對同一個對象（vector）連續加鎖、解鎖操做，會合並一個更大範圍的加鎖、解鎖操做，即加鎖解鎖操做會移到for循環以外。

輕量級鎖
引入輕量級鎖的主要目的是在多沒有多線程競爭的前提下，減小傳統的重量級鎖使用操做系統互斥量產生的性能消耗。當關閉偏向鎖功能或者多個線程競爭偏向鎖致使偏向鎖升級爲輕量級鎖，則會嘗試獲取輕量級鎖，其步驟以下：
獲取鎖
1. 判斷當前對象是否處於無鎖狀態（hashcode、0、01），如果，則JVM首先將在當前線程的棧幀中創建一個名爲鎖記錄（Lock Record）的空間，用於存儲鎖對象目前的Mark Word的拷貝（官方把這份拷貝加了一個Displaced前綴，即Displaced Mark Word）；不然執行步驟（3）；
2. JVM利用CAS操做嘗試將對象的Mark Word更新爲指向Lock Record的指正，若是成功表示競爭到鎖，則將鎖標誌位變成00（表示此對象處於輕量級鎖狀態），執行同步操做；若是失敗則執行步驟（3）；
3. 判斷當前對象的Mark Word是否指向當前線程的棧幀，若是是則表示當前線程已經持有當前對象的鎖，則直接執行同步代碼塊；不然只能說明該鎖對象已經被其餘線程搶佔了，這時輕量級鎖須要膨脹爲重量級鎖，鎖標誌位變成10，後面等待的線程將會進入阻塞狀態；

釋放鎖
輕量級鎖的釋放也是經過CAS操做來進行的，主要步驟以下：
1. 取出在獲取輕量級鎖保存在Displaced Mark Word中的數據；
2. 用CAS操做將取出的數據替換當前對象的Mark Word中，若是成功，則說明釋放鎖成功，不然執行（3）；
3. 若是CAS操做替換失敗，說明有其餘線程嘗試獲取該鎖，則須要在釋放鎖的同時須要喚醒被掛起的線程。

對於輕量級鎖，其性能提高的依據是「對於絕大部分的鎖，在整個生命週期內都是不會存在競爭的」，若是打破這個依據則除了互斥的開銷外，還有額外的CAS操做，所以在有多線程競爭的狀況下，輕量級鎖比重量級鎖更慢；

下圖是輕量級鎖的獲取和釋放過程

偏向鎖
引入偏向鎖主要目的是：爲了在無多線程競爭的狀況下儘可能減小沒必要要的輕量級鎖執行路徑。上面提到了輕量級鎖的加鎖解鎖操做是須要依賴屢次CAS原子指令的。那麼偏向鎖是如何來減小沒必要要的CAS操做呢？咱們能夠查看Mark work的結構就明白了。只須要檢查是否爲偏向鎖、鎖標識爲以及ThreadID便可，處理流程以下：
獲取鎖
1. 檢測Mark Word是否爲可偏向狀態，便是否爲偏向鎖1，鎖標識位爲01；
1. 若爲可偏向狀態，則測試線程ID是否爲當前線程ID，若是是，則執行步驟（5），不然執行步驟（3）；
1. 若是線程ID不爲當前線程ID，則經過CAS操做競爭鎖，競爭成功，則將Mark Word的線程ID替換爲當前線程ID，不然執行線程（4）；
4. 經過CAS競爭鎖失敗，證實當前存在多線程競爭狀況，當到達全局安全點，得到偏向鎖的線程被掛起，偏向鎖升級爲輕量級鎖，而後被阻塞在安全點的線程繼續往下執行同步代碼塊；
5. 執行同步代碼塊

釋放鎖
偏向鎖的釋放採用了一種只有競爭纔會釋放鎖的機制，線程是不會主動去釋放偏向鎖，須要等待其餘線程來競爭。偏向鎖的撤銷須要等待全局安全點（這個時間點是上沒有正在執行的代碼）。其步驟以下：
1. 暫停擁有偏向鎖的線程，判斷鎖對象石是否還處於被鎖定狀態；
2. 撤銷偏向蘇，恢復到無鎖狀態（01）或者輕量級鎖的狀態；

下圖是偏向鎖的獲取和釋放流程

重量級鎖
重量級鎖經過對象內部的監視器（monitor）實現，其中monitor的本質是依賴於底層操做系統的Mutex Lock實現，操做系統實現線程之間的切換須要從用戶態到內核態的切換，切換成本很是高。

參考資料 周志明：《深刻理解Java虛擬機》 方騰飛：《Java併發編程的藝術》 Java中synchronized的實現原理與應用）