面试必问synchronized关键字详解-技术圈

synchronized 这个关键字，我相信对于并发编程有一定了解的人，一定会特别熟悉，这也是面试时经常被问的一个面试点。

大多数人对这个关键字的理解就是对于一些可能在多线程环境下可能会有并发问题的代码，直接加上synchronized，问题就搞定了。

但是用归用，你明白它为什么要这么用？为什么就能解决我们所说的线程安全问题？

下面，可乐将和大家一起深入的探讨这个关键字用法。

1、示例代码结果？

首先大家看一段代码，大家想想最后的打印count结果是多少？

package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;


/**
 * Create by ItCoke
 */
public class SynchronizedTest implements Runnable{

    public static int count = 0;

    @Override
    public void run() {
        addCount();

    }

    public void addCount(){
        int i = 0;
        while (i++ < 100000) {
            count++;
        }
    }

    public static void main(String[] args) throws Exception{
        SynchronizedTest obj = new SynchronizedTest();
        Thread t1 = new Thread(obj);
        Thread t2 = new Thread(obj);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);

    }


}

代码很简单，主线程中启动两个线程t1和t2，分别调用 addCount() 方法，将count的值都加100000，然后调用 join() 方法，表示主线程等待这两个线程执行完毕。最后打印 count 的值。

应该没有答案一定是 200000 的同学吧，很好，大家都具备一定的并发知识。

这题的答案是一定小于等于 200000，至于原因也很好分析，比如 t1线程获取count的值为0，然后执行了加1操作，但是还没来得及同步到主内存，这时候t2线程去获取主内存的count值，发现还是0，然后继续自己的加1操作。也就是t1和t2都执行了加1操作，但是最后count的值依然是1。

那么我们应该如何保证结果一定是 200000呢？答案就是用 synchronized

2、修饰代码块

直接上代码：

package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;


/**
 * Create by ItCoke
 */
public class SynchronizedTest implements Runnable{

    public static int count = 0;

    private Object objMonitor = new Object();

    @Override
    public void run() {
        addCount();

    }

    public void addCount(){
        synchronized (objMonitor){
            int i = 0;
            while (i++ < 100000) {
                count++;
            }
        }

    }

    public static void main(String[] args) throws Exception{
        SynchronizedTest obj = new SynchronizedTest();
        Thread t1 = new Thread(obj);
        Thread t2 = new Thread(obj);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);

    }


}

我们在 addCount 方法体中增加了一个 synchronized 代码块，将里面的 while 循环包括在其中，保证同一时刻只能有一个线程进入这个循环去改变count的值。

3、修饰普通方法

package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;


/**
 * Create by ItCoke
 */
public class SynchronizedTest implements Runnable{

    public static int count = 0;

    private Object objMonitor = new Object();

    @Override
    public void run() {
        addCount();

    }

    public synchronized void addCount(){
        int i = 0;
        while (i++ < 100000) {
            count++;
        }

    }

    public static void main(String[] args) throws Exception{
        SynchronizedTest obj = new SynchronizedTest();
        Thread t1 = new Thread(obj);
        Thread t2 = new Thread(obj);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);

    }


}

对比上面修饰代码块，直接将 synchronized 加到 addCount 方法中，也能解决线程安全问题。

4、修饰静态方法

这个我们就不贴代码演示了，将 addCount() 声明为一个 static 修饰的方法，然后在加上 synchronized ，也能解决线程安全问题。

5、原子性、可见性、有序性

通过 synchronized 修饰的方法或代码块，能够同时保证这段代码的原子性、可见性和有序性，进而能够保证这段代码的线程安全。

比如通过 synchronized 修饰的代码块：

其中 objMonitor 表示锁对象（下文会介绍这个锁对象），只有获取到这个锁对象之后，才能执行里面的代码，执行完毕之后，在释放这个锁对象。那么同一时刻就会只有一个线程去执行这段代码，把多线程变成了单线程，当然不会存在并发问题了。

这个过程，大家可以想象在公司排队上厕所的情景。

对于原子性，由于同一时刻单线程操作，肯定能够保证原子性。

对于有序性，在JMM内存模型中的Happens-Before规定如下，所以也是能够保证有序性的。

程序的顺序性规则（Program Order Rule）：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。

最后对于可见性，JMM内存模型也规定了：

对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store、write操作）。

大家可能会奇怪，synchronized 并没有lock和unlock操作啊，怎么也能够保证可见性，大家不要急，其实JVM对于这个关键字已经隐式的实现了，下文看字节码会明白的。

6、锁对象

大家要注意，我在通过synchronized修饰同步代码块时，使用了一个 Object 对象，名字叫 objMonitor。而对于修饰普通方法和静态方法时，只是在方法声明时说明了，并没有锁住什么对象，其实这三者都有各自的锁对象，只有获取了锁对象，线程才能进入执行里面的代码。

1、修饰代码块：锁定锁的是synchonized括号里配置的对象 2、修饰普通方法：锁定调用当前方法的this对象 3、修饰静态方法：锁定当前类的Class对象

多个线程之间，如果要通过 synchronized 保证线程安全，获取的要是同一把锁。如果多个线程多把锁，那么就会有线程安全问题。如下：

package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;


/**
 * Create by ItCoke
 */
public class SynchronizedTest implements Runnable{

    public static int count = 0;



    @Override
    public void run() {
        addCount();

    }

    public void addCount(){
        Object objMonitor = new Object();
        synchronized(objMonitor){
            int i = 0;
            while (i++ < 100000) {
                count++;
            }
        }
    }

    public static void main(String[] args) throws Exception{
        SynchronizedTest obj = new SynchronizedTest();
        Thread t1 = new Thread(obj);
        Thread t2 = new Thread(obj);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);

    }


}

我们把原来的锁 objMonitor 对象从全局变量移到 addCount() 方法中，那么每个线程进入每次进入addCount() 方法都会新建一个 objMonitor 对象，也就是多个线程用多把锁，肯定会有线程安全问题。

7、可重入

可重入什么意思？字面意思就是一个线程获取到这个锁了，在未释放这把锁之前，还能进入获取锁，如下：

在 addCount() 方法的 synchronized 代码块中继续调用 printCount() 方法，里面也有一个 synchronized ，而且都是获取的同一把锁——objMonitor。

synchronized 是能够保证这段代码正确运行的。至于为什么具有这个特性，可以看下文的实现原理。

8、实现原理

对于如下这段代码：

package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;

/**
 * Create by YSOcean
 */
public class SynchronizedByteClass {
    Object objMonitor = new Object();

    public synchronized void method1(){
        System.out.println("Hello synchronized 1");
    }

    public synchronized static void method2(){
        System.out.println("Hello synchronized 2");
    }

    public void method3(){
        synchronized(objMonitor){
            System.out.println("Hello synchronized 2");
        }

    }

    public static void main(String[] args) {

    }
}

我们可以通过两种方法查看其class文件的汇编代码。

①、IDEA下载 jclasslib 插件

然后点击 View——Show Bytecode With jclasslib

　　②、通过 javap 命令

javap -v 文件名（不要后缀）

注意：这里生成汇编的命令是根据编译之后的字节码文件（class文件），所以要先编译。

③、修饰代码块汇编代码

我们直接看method3() 的汇编代码：

　　对于上图出现的 monitorenter 和 monitorexit 指令，我们查看 JVM虚拟机规范：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html，可以看到对这两个指令的介绍。

下面我们说明一下这两个指令：

一、monitorenter

　　每个对象与一个监视器锁（monitor）关联。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

1、如果 monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

二、monitorexit　　执行monitorexit的线程必须是object ref所对应的monitor的所有者。

指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

通过上面介绍，我们可以知道 synchronized 底层就是通过这两个命令来执行的同步机制，由此我们也可以看出synchronized 具有可重入性。

③、修饰普通方法和静态方法汇编代码　　可以看到都是通过指令 ACC_SYNCHRONIZED 来控制的，虽然没有看到方法的同步并没有通过指令monitorenter和monitorexit来完成，但其本质也是通过这两条指令来实现。

当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。其实和修饰代码块本质上没有区别，只是方法的同步是一种隐式的方式来实现。

9、异常自动unlock

可能会有细心的朋友发现，我在介绍 synchronized 修饰代码块时，给出的汇编代码，用红框圈住了两个 monitorexit，根据我们前面介绍，获取monitor加1，退出monitor减1，等于0时，就没有锁了。那为啥会有两个 monitorexit，而只有一个 monitorenter 呢？　　第 6 行执行 monitorenter，然后第16行执行monitorexit，然后执行第17行指令 goto 25，表示跳到第25行代码，第25行是 return，也就是直接结束了。

那第20-24行代码中是什么意思呢？其中第 24 行指令 athrow 表示Java虚拟机隐式处理方法完成异常结束时的监视器退出，也就是执行发生异常了，然后去执行 monitorexit。

进而可以得到结论：

synchronized 修饰的方法或代码块，在执行过程中抛出异常了，也能释放锁（unlock）

我们可以看如下方法，手动抛出异常：

　　然后获取其汇编代码，就只有一个 monitorexit 指令了。