关于synchronized的面试题

在面试过程中，我们经常会被考察多线程的问题。多线程虽然好用，但若使用不当将会带来很多并发问题。如何保证线程安全自然是绕不开的话题。

最近公司要招贤纳士，在面试的过程中，我发现所有人都知道关键字synchronized是用来线程同步，保证线程安全的。但是再深入聊下去，很容易陷入尴尬之境。我也只能客气地说“换个话题“，或者“今天就先聊到这里“…（PS:会不会我太装13了呢？但是简历上一般都是5+的工作经验）

2020注定是不平凡的一年。正值疫情期间，每一次面试机会就显得尤为重要。所以特地抽出时间来写这篇文章，希望能够帮助每位面试者找到心仪的工作。

1. synchronized的简介

synchronized要理解为加锁，而不是锁，这个思维有助于你更好的理解线程同步。

1.1 synchronized的使用及各自的锁对象

这里简要介绍一下，为以后的内容做一下铺垫：

1. 普通方法 ：锁对象是this，所谓的方法锁（本质上属于对象锁)

public synchronized void say(){
     
	 System.out.println("Hello,everyone...");
}

2. 同步代码块(方法中)：锁对象是synchronized(obj)的对象，所谓的对象锁

 public  void say(boolean isYou){
     
        synchronized (obj){
     
            System.out.println("Hello");
        }
    }

3. 同步静态方法：锁对象是当前类的Class对象,即(XXX.class)，所谓的类锁

 public static synchronized void work(){
     
        System.out.println("Work hard...");
    }

希望大家再遇到对象锁,类锁而不知所措…有时候遇到面试官把问题描述的不够清楚时，要勇于及时和面试官沟通。虽然找工作时总会遇到奇葩面试官，但是如果你遇到的几率太高时，请自觉地审视一下自己…

---

1.2 synchronized的关于代码块的疑问

看到上面synchronized的用法，你会有这样的疑问吗？synchronized能修饰类级别(静态)代码块吗？(PS: 这个话题是我临时想起的,改天在面试中问一下看看效果…)

结论：synchronized不能用在类级别的(静态)代码块

如果在面试中不给你编译器，大多数人估计都是要mountain泰吧。这里直接给出我的理解：

这个要从加载顺序上考虑。
类级别的代码块在加载顺序上是要优先于任何方法的，其执行顺序只跟代码位置先后有关。没人跟你抢，自然不需要同步。

---

2. 涉及synchronized的面试题

这里通过一个常见的面试题-单例模式来展开，这篇文章主要内容是考察synchronized关键字的，就直奔主题进入DCL(Double Check Lock)双重校验锁的单例。

2.1 围绕着DCL展开的话题

2.1.1 实现DCL

如果这步就过不了，就尴尬无止境啦…

public class SingleInstance {
     
    private volatile static SingleInstance instance = null;
    private SingleInstance(){
      }
    public static SingleInstance getInstance(){
     
        if (instance == null){
     
            synchronized (SingleInstance.class){
     
                if (instance == null){
     
                    instance = new SingleInstance();
                }
            }
        }
        return instance;
    }
}

2.1.2 谈一下synchronized的作用

synchronized 关键字主要用来解决的是多线程同步问题，其可以保证在被其修饰的代码任意时刻只有一个线程执行。视情况而定，（主动)说出它的用法及底层实现原理(使用的是moniterenter 和 moniterexit指令…)，PS：synchronized的底层实现原理会单独展开…

2.1.3 这里(DCL)的volatile的作用

volatile只能保证变量的可见性，并不能保证对volatile修饰的变量的操作的原子性。

volatile的主要作用：

1. 保持内存可见性；使所有线程都能看到共享内存的最新状态。
2. 防止指令重排的问题；

通过设置内存屏障实现的。感兴趣的可以去看一下深入理解Java虚拟机

个人拙见，能答出来上面的内容即可，更深入的绝大部分都是在SHOW或者就是压薪资…

2.2 基础面试点

为了节约各位看官的时间，先把结论给出来：

1. 若是对象锁，则每个对象都持有一把自己的独一无二的锁，且对象之间的锁互不影响 。若是类锁，所有该类的对象共用这把锁。
2. 一个线程获取一把锁，没有得到锁的线程只能排队等待；
3. synchronized 是可重入锁，避免很多情况下的死锁发生。
4. synchronized 方法若发生异常，则JVM会自动释放锁。
5. 锁对象不能为空，否则抛出NPE(NullPointerException)
6. 同步本身是不具备继承性的：即父类的synchronized 方法，子类重写该方法,分情况讨论：没有synchonized修饰，则该子类方法不是线程同步的。(PS ：涉及同步继承性的问题要分情况)
7. synchronized本身修饰的范围越小越好。毕竟是同步阻塞。跑不快还占着超车道…

---

2.2.1 同时访问synchronized的静态和非静态方法，能保证线程安全吗？

结论：不能，两者的锁对象不一样。前者是类锁(XXX.class),后者是this

2.2.2 同时访问synchronized方法和非同步方法，能保证线程安全吗？

结论：不能，因为synchronized只会对被修饰的方法起作用。

2.2.3 两个线程同时访问两个对象的非静态同步方法能保证线程安全吗？

结论：不能，每个对象都拥有一把锁。两个对象相当于有两把锁，导致锁对象不一致。(PS：如果是类锁，则所有对象共用一把锁)

2.2.4 若synchronized方法抛出异常，会导致死锁吗？

JVM会自动释放锁，不会导致死锁问题

2.2.5 若synchronized的锁对象能为空吗？会出现什么情况？

锁对象不能为空，否则抛出NPE(NullPointerException)

2.2.6 若synchronized的锁对象能为空吗？会出现什么情况？

锁对象不能为空，否则抛出NPE(NullPointerException)

---

2.3 关于继承性的面试点

2.3.1 synchronized涉及的继承性问题

重写父类的synchronized的方法，主要分为两种情况：

1. 子类的方法没有被synchronized修饰：

synchronized的不具备继承性。所以子类方法是线程不安全的。

3. 子类的方法被synchronized修饰(这里面试点主要考察锁对象的归属问题)：

两个锁对象其实是一把锁，而且是子类对象作为锁。这也证明了: synchronized的锁是可重入锁。否则将出现死锁问题。

2.4 实战经验的面试点

2.4.1 在开发过程中，你经常使用synchronized方法多还是synchronized代码块？and why?

关于synchronized 的内容部分，我在面试过程中经常问且只问这一道题。本人认为这个能很好的考察面试者的综合素质。(PS：毕竟是要拧螺丝的…)

synchronized同步的范围是越小越好。因为若该方法耗时很久，那其它线程必须等到该持锁线程执行完才能运行。(黄花菜都凉了都…)
而synchronized代码块部分只有这一部分是同步的，其它的照样可以异步执行，提高运行效率。

2.4.2 请写一个死锁的例子

这里给大家一个参考：我有故事，你有酒吗？

public class DeadLock {
     
    String story = "故事";
    String wine = "酒";

    public  void wantWine() throws InterruptedException {
     
        synchronized (story){
     
            System.out.println("已经拥有："+ story +"就缺："+ wine);
            Thread.sleep(1000);
            synchronized (wine){
     
                System.out.println("拥有："+ wine);
            }
        }
    }

    public void wantStory() throws InterruptedException {
     
        synchronized (wine){
     
            System.out.println("已经拥有："+ wine +"就缺："+ story);
            Thread.sleep(1000);
            synchronized (story){
     
                System.out.println("拥有："+ story);
            }
        }
    }

    public static void main(String[] args) {
     
        DeadLock deadLock = new DeadLock();

        new Thread(new Runnable() {
     
            @Override
            public void run() {
     
                try {
     
                    deadLock.wantWine();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
     
            @Override
            public void run() {
     
                try {
     
                    deadLock.wantStory();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
            }
        }).start();

    }
}

2.4.2 有没有遇到过synchronized失效的问题？

对于这种问法，主要是考察面试者在实际开发中的经验是否丰富…，可以如实回答的。

synchronized 虽然用法简单，但是如果锁对象不一致，就会失效。排查问题的时候一定要着重从锁对象是否一致上去判断.

细心的读者会发现，净XC，居然没有对synchronized的原理进行分析，以及在JDK1.6时，Java官方对synchronized做了优化也没有提及。不要着急，后续补充…