Synchronized面试题

沧浪之水12010137

已于 2024-03-11 18:00:17 修改

阅读量479

点赞数

分类专栏： juc 文章标签： java

于 2023-11-16 01:07:10 首次发布

本文链接：https://blog.csdn.net/weixin_44582492/article/details/134432588

版权

juc 专栏收录该内容

10 篇文章

订阅专栏

一：轻量锁和偏向锁的区别：

（1）争夺轻量锁失败时，自旋尝试抢占锁
（2）轻量级锁每次退出同步块都需要释放锁，而偏向锁是在竞争发生时才释放锁，线程不会主动释放偏向锁

二：为什么每个对象都能作为一个锁？

java对象是天生的Monitor，每一个对象都有成为Monitor的潜质，因为在Java设计中，每一个Java对象自打娘胎里出来就带一个看不见的锁，它叫内部锁或者Monitor锁

三：Monitror与java对象以及线程如何关联？

四:锁升级后，hashcode去哪儿了?

在这里插入图片描述

五：什么是锁消除？

/**
 /**
 * @Author：xiaoqi
 * @creat 2023/8/12 11:27
 * 锁消除
 * 从JIT角度看想相当于无视他，synchronized(o)不存在了
 * 这个锁对象并没有被共用扩散到其他线程使用
 * 极端的说就是根本没有加锁对象的底层机器码，消除了锁的使用
 */
public class LockClearUpDemo {
    static Object object = new Object();

    public void m1() {
        //锁消除问题，JIT会无视它，synchronized(o)每次new出来的，都不存在了，非正常的
        Object o = new Object();
        synchronized (o) {
            System.out.println("-----------hello LockClearUpDemo" + "\t" + o.hashCode() + "\t" + object.hashCode());
        }
    }

    public static void main(String[] args) {
        LockClearUpDemo lockClearUpDemo = new LockClearUpDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                lockClearUpDemo.m1();
            }, String.valueOf(i)).start();
        }
    }
}
/**
 * -----------hello LockClearUpDemo	229465744	57319765
 * -----------hello LockClearUpDemo	219013680	57319765
 * -----------hello LockClearUpDemo	1109337020	57319765
 * -----------hello LockClearUpDemo	94808467	57319765
 * -----------hello LockClearUpDemo	973369600	57319765
 * -----------hello LockClearUpDemo	64667370	57319765
 * -----------hello LockClearUpDemo	1201983305	57319765
 * -----------hello LockClearUpDemo	573110659	57319765
 * -----------hello LockClearUpDemo	1863380256	57319765
 * -----------hello LockClearUpDemo	1119787251	57319765
 */

六：什么是锁粗化？

/**
 * @Author：xiaoqi
 * @creat 2023/8/12 12:27
 * 锁粗化
 * 假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器会把这几个synchronized块合并为一个大块
 * 加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提高了性能
 */
public class LockBigDemo {
    static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println("111111111111");
            }
            synchronized (objectLock) {
                System.out.println("222222222222");
            }
            synchronized (objectLock) {
                System.out.println("333333333333");
            }
            synchronized (objectLock) {
                System.out.println("444444444444");
            }
            //底层JIT的锁粗化优化
            synchronized (objectLock) {
                System.out.println("111111111111");
                System.out.println("222222222222");
                System.out.println("333333333333");
                System.out.println("444444444444");
            }
        }, "t1").start();
    }
}

七：synchronized是怎么实现的?

同步方法的常量池中会有一ACC_SYNCHRONIZED 标志。当某个线程要访问某个方法的时候，会检查是否有 ACC_SYNCHRONIZED），如果有设置，则需要先获得监视器锁，然后开始执行方法，方法执行之后再释放监视器锁。这时如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住。值得注意的是，如果在方法执行过程中,发生了异常，并且方法内部并没有处理该异常，那么在异常被抛到方法外面之前监视器锁会被自动释放。
同步代码块使用(monitorenter和 monitorexit 两个指令实现。可以把执行（monitorent
er指令理解为加锁，执行（monitorexit」理解为释放锁。每个对象维护着一个记录着被锁次
数的计数器。未被锁定的对象的该计数器为 0，当一个线程获得锁（执行（monitorenter））
后，该计数器自增变为 1 ，当同一个线程再次获得该对象的锁的时候，计数器再次自增。当同一个线程释放锁（执行（monitorexit）指令）的时候，计数器再自减。当计数器为 0 的时候。锁将被释放，其他线程便可以获得锁。

八：synchronized锁的是什么？

同步方法：public synchronized void print(){}
public static synchronized void print(){}
同步代码块：synchronized (this){}
synchronized (Xxx.class){}
总结一下：

synchronized的普通方法，其实锁的是调用这个方法的实例对象，而synchronized的静态方法，其实锁的是这个方法属于的类对象。
synchronized(this)，其实锁的是this这个实例对象，而synchronized(Xxx.Class)，其实锁的是这个类对象。
一个类只有一个类对象，但是有很多个实例对象。

九：synchronized是如何保证原子性、可见性、有序性的？

synchronized如何保证的原子性呢？
synchonized其实是通过 monitorenter 和 monitorexit 这两个字节码指令实现的。当线程执行到 monitorenter 的时候要先获得锁，才能执行后面的方法。当线程执行到monitorexit 的时候则要释放锁,在未释放之前，其他线程是无法再次获得锁的，
synchronized如何保证有序性？
由于synchronized修饰的代码，同一时间只能被同一线程访问，所以，可以保证其有序性。
synchronized如何保证可见性？
被synchronized修饰的代码，在开始执行时会加锁，执行完成后会进行解锁。而为了保证可见性，有一条规则是这样的：对一个变量解锁之前，必须先把此变量同步回主存中。这样解锁后,后续线程就可以访问到被修改后的值。

十：synchronized的锁升级过程是怎样的？

在JDK 1.6之后，锁的升级过程，分别是无锁、偏向锁、轻量级锁和重量级锁，锁升级功能主要依赖MarkWord中锁标志位和释放偏向锁标志位
无锁：初始状态，一个对象被实例化之后，如果还没有被任何线程竞争锁，那么它就是无锁状态
偏向锁：单线程竞争，当线程A第一次竞争到锁时，通过修改MarkWord中的偏向线程ID、偏向模式。如果不存在其他线程竞争，那么持有偏向锁的线程将永远不需要进行同步。
轻量级锁：当有另外一个线程逐步来竞争锁的时候，就不能再使用偏向锁了，要升级为轻量级锁，竞争线程尝试CAS更新对象头失败，同时检查持有偏向锁的线程是否还在执行：
（1）第一个线程正在执行Synchronized方法（处于同步块），它还没有执行完，其他线程来抢夺，该偏向锁会被取消掉并出现锁升级，此时轻量级锁由原来持有偏向锁的线程持有，继续执行同步代码块，而正在竞争的线程会自动进入自旋等待获得该轻量级锁
重量级锁：自旋一定程度和次数，升级到重量级锁

十一：synchronized升级过程中有几次自旋？

第一次自旋：第一次自旋发生在获取轻量级锁时，当一个线程尝试获取一个被其他线程持有的轻量级锁时，它会自旋等待锁的持有者释放锁。
第二次自旋：发生在 synchronized 轻量级锁升级到重量级锁的过程中，即当一个线程尝试获取一个被其他线程持有的重量级锁时，它会自旋等待锁的持有者释放锁。
自适应自旋：在尝试获取轻量级锁时，线程会进行自旋，等待拥有锁的线程释放锁。但这里的自旋不是固定次数的，而是根据前一次自旋的时间和成功获取锁的概率进行自适应调整。