每天用Synchronized，底層原理是個啥？

時間 2020-05-08

標籤每天 synchronized 底層原理欄目 Java 简体版

原文原文鏈接

做者：iuxiaopeng
https://www.cnblogs.com/paddi...

Synchronized 的基本使用html

Synchronized 的做用主要有三個：java

確保線程互斥的訪問同步代碼
保證共享變量的修改可以及時可見
有效解決重排序問題

從語法上講，Synchronized 總共有三種用法：面試

修飾普通方法
修飾靜態方法
修飾代碼塊

接下來我就經過幾個例子程序來講明一下這三種使用方式（爲了便於比較，三段代碼除了 Synchronized 的使用方式不一樣之外，其餘基本保持一致）。編程

沒有同步的狀況後端

代碼段 1：安全

package com.paddx.test.concurrent;

public class SynchronizedTest {
  public void method1(){

    System.out.println("Method 1 start");
    try {
      System.out.println("Method 1 execute");
      Thread.sleep(3000);
    } catch (InterruptedException e) {
       e.printStackTrace();
    }
    System.out.println("Method 1 end");
  }

  public void method2(){
    System.out.println("Method 2 start");
    try {
      System.out.println("Method 2 execute");
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 2 end");
  }

  public static void main(String\[\] args) {
    final SynchronizedTest test = new SynchronizedTest();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method1();
      }
    }).start();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method2();
      }
    }).start();
  }
}

執行結果以下，線程 1 和線程 2 同時進入執行狀態，線程 2 執行速度比線程 1 快，因此線程 2 先執行完成。推薦閱讀：多線程 start 和 run 方法到底有什麼區別？多線程

這個過程當中線程 1 和線程 2 是同時執行的：架構

Method 1 start
Method 1 execute
Method 2 start
Method 2 execute
Method 2 end
Method 1 end

對普通方法同步併發

代碼段 2：ide

package com.paddx.test.concurrent;

public class SynchronizedTest {
  public synchronized void method1(){
    System.out.println("Method 1 start");
    try {
      System.out.println("Method 1 execute");
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 1 end");
  }

  public synchronized void method2(){
    System.out.println("Method 2 start");
    try {
      System.out.println("Method 2 execute");
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 2 end");
  }

  public static void main(String\[\] args) {
    final SynchronizedTest test = new SynchronizedTest();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method1();
      }
    }).start();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method2();
      }
    }).start();
  }
}

執行結果以下，跟代碼段 1 比較，能夠很明顯的看出，線程 2 須要等待線程 1 的 Method1 執行完成才能開始執行 Method2 方法。

Method 1 start
Method 1 execute
Method 1 end
Method 2 start
Method 2 execute
Method 2 end

靜態方法（類）同步

代碼段 3：

package com.paddx.test.concurrent;

public class SynchronizedTest {
  public static synchronized void method1(){
    System.out.println("Method 1 start");
    try {
      System.out.println("Method 1 execute");
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 1 end");
  }

  public static synchronized void method2(){
    System.out.println("Method 2 start");
    try {
      System.out.println("Method 2 execute");
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 2 end");
  }

  public static void main(String\[\] args) {
    final SynchronizedTest test = new SynchronizedTest();
    final SynchronizedTest test2 = new SynchronizedTest();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method1();
      }
    }).start();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test2.method2();
      }
    }).start();
  }
 }

執行結果以下，對靜態方法的同步本質上是對類的同步（靜態方法本質上是屬於類的方法，而不是對象上的方法）。

因此即便 Test 和 Test2 屬於不一樣的對象，可是它們都屬於 SynchronizedTest 類的實例。

因此也只能順序的執行 Method1 和 Method2，不能併發執行：

Method 1 start
Method 1 execute
Method 1 end
Method 2 start
Method 2 execute
Method 2 end

代碼塊同步

代碼段 4：

package com.paddx.test.concurrent;

public class SynchronizedTest {
  public void method1(){
    System.out.println("Method 1 start");
    try {
      synchronized (this) {
        System.out.println("Method 1 execute");
        Thread.sleep(3000);
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 1 end");
  }

  public void method2(){
    System.out.println("Method 2 start");
    try {
      synchronized (this) {
        System.out.println("Method 2 execute");
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Method 2 end");
  }

  public static void main(String\[\] args) {
    final SynchronizedTest test = new SynchronizedTest();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method1();
      }
    }).start();

    new Thread(new Runnable() {
      @Override
      public void run() {
        test.method2();
      }
    }).start();
  }
}

執行結果以下，雖然線程 1 和線程 2 都進入了對應的方法開始執行，可是線程 2 在進入同步塊以前，須要等待線程 1 中同步塊執行完成。

Method 1 start
Method 1 execute
Method 2 start
Method 1 end
Method 2 execute
Method 2 end

Synchronized 原理

若是對上面的執行結果還有疑問，也先不用急，咱們先來了解 Synchronized 的原理。推薦閱讀：面試常考：Synchronized 有幾種用法？

再回頭上面的問題就一目瞭然了。咱們先經過反編譯下面的代碼來看看 Synchronized 是如何實現對代碼塊進行同步的：

package com.paddx.test.concurrent;
public class SynchronizedMethod {
  public synchronized void method() {
    System.out.println("Hello World!");
  }
}

反編譯結果：

關於這兩條指令的做用，咱們直接參考 JVM 規範中描述：

monitorenter ：Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:

• If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.

• If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.

• If another thread already owns the monitor associated with objectref, the thread blocks until the monitor's entry count is zero, then tries again to gain ownership.

這段話的大概意思爲：每一個對象有一個監視器鎖（Monitor），當 Monitor 被佔用時就會處於鎖定狀態。

線程執行 Monitorenter 指令時嘗試獲取 Monitor 的全部權，過程以下：

若是 Monitor 的進入數爲 0，則該線程進入 Monitor，而後將進入數設置爲 1，該線程即爲 Monitor 的全部者。
若是線程已經佔有該 Monitor，只是從新進入，則進入 Monitor 的進入數加 1。
若是其餘線程已經佔用了 Monitor，則該線程進入阻塞狀態，直到 Monitor 的進入數爲 0，再從新嘗試獲取 Monitor 的全部權。

monitorexit：The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.

The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner.

Other threads that are blocking to enter the monitor are allowed to attempt to do so.

這段話的大概意思爲：執行 Monitorexit 的線程必須是 Objectref 所對應的 Monitor 的全部者。

指令執行時，Monitor 的進入數減 1，若是減 1 後進入數爲 0，那線程退出 Monitor，再也不是這個 Monitor 的全部者。

其餘被這個 Monitor 阻塞的線程能夠嘗試去獲取這個 Monitor 的全部權。

經過這兩段描述，咱們應該能很清楚的看出 Synchronized 的實現原理。

Synchronized 的語義底層是經過一個 Monitor 的對象來完成，其實 Wait/Notify 等方法也依賴於 Monitor 對象。推薦閱讀：Synchronized 與 ReentrantLock 的區別！

這就是爲何只有在同步的塊或者方法中才能調用 Wait/Notify 等方法，不然會拋出 java.lang.IllegalMonitorStateException 的異常。

咱們再來看一下同步方法的反編譯結果，源代碼以下：

package com.paddx.test.concurrent;

public class SynchronizedMethod {
  public synchronized void method() {
    System.out.println("Hello World!");
  }
}

反編譯結果：