关于synchronized的面试题

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

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

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

1. synchronized的简介

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

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

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

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

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

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

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

同步静态方法：锁对象是当前类的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的主要作用：

保持内存可见性；使所有线程都能看到共享内存的最新状态。

防止指令重排的问题；

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

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

2.2 基础面试点

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

若是对象锁，则每个对象都持有一把自己的独一无二的锁，且对象之间的锁互不影响。若是类锁，所有该类的对象共用这把锁。

一个线程获取一把锁，没有得到锁的线程只能排队等待；

synchronized 是可重入锁，避免很多情况下的死锁发生。

synchronized 方法若发生异常，则JVM会自动释放锁。

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

同步本身是不具备继承性的：即父类的synchronized 方法，子类重写该方法,分情况讨论：没有synchonized修饰，则该子类方法不是线程同步的。(PS ：涉及同步继承性的问题要分情况)

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的方法，主要分为两种情况：

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

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

子类的方法被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做了优化也没有提及。不要着急，后续补充…

Bert.King

发布了23 篇原创文章 · 获赞 14 · 访问量 9万+

私信关注