每天用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!");
  }
}

反编译结果：