面试题——Java中的锁

已于 2022-06-02 21:19:31 修改
阅读量3.1k 收藏 45
点赞数 3
分类专栏： 面试题 —— JVM
于 2022-05-21 15:11:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q_P777/article/details/124894748
版权

java

文章目录

谈谈你对线程安全的理解？

  • 谈到线程安全问题，就得先说一下什么是共享资源。所谓共享资源，就是说该资源被多个线程所持有或者说多个线程都可以去访问该资源。
  • 线程安全问题是指当多个线程同时读写一个共享资源并且没有任何同步措施时，导致出现脏数据或者其他不可预见的结果的问题。

1、synchronized 关键字是怎么用的？

synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

  • 主要有三种使用方法：

  1. 修饰实例方法: 给当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。

  2. 修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例 ，进入同步代码前要获得 当前 class 的锁。

  3. 修饰代码块 ：指定加锁对象，对给定对象/类加锁。

    // 1.修饰实例方法
synchronized void method1() {
	//业务代码
}
//2.修饰静态方法
synchronized static void method2() {
	//业务代码
}
//3.修饰代码块
synchronized(this) {
	//业务代码
}

1.1 构造方法可以使用 synchronized 关键字修饰么？

  • 不能。JAVA 语法规定构造方法不能被 synchronized 关键词修饰。
  • 前面说了，synchronized 关键字作用于方法上，是给当前对象实例/类加锁，而在构造方法上加 synchronized ，此时对象实例还没产生；另一方面，构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步 。

1.2 使用 String 作为锁对象，会有什么问题？

  • 类似于 “String 对象创建了几个” 这样的问题，如果一个方法以参数中传来的 String 对象作为锁，那么就需要保证这个 String 对象在所有线程中的地址是一致的。

参考：https://blog.csdn.net/headingalong/article/details/86505420

1.3 synchronized 的底层原理有了解吗？

  • 每个 Java 对象都可以关联一个 Monitor 对象，也就是我们常说的锁。
  • 使用 synchronized 关键字来同步代码块，在 JVM 层面使用了 monitorenter 和 monitorexit 指令来实现。
  • 在执行到 monitorenter 指令时，线程会尝试获取对象所对应的 Monitor 对象的所有权，只有获取到所有权的线程才能够执行同步代码块中的内容。而没有获取到 Monitor 所有权的线程会进入阻塞状态。

1.4 synchronized 怎么保证可重入性？可见性？抛异常怎么办？

可重入：

  • 可重入锁的原理是在锁内部维护一个线程标示，用来标示该锁目前被哪个线程占用，然后关联一个计数器。一开始计数器值为0，说明该锁没有被任何线程占用。当一个钱程获取了该锁时，计数器的值会变成1 ，这时其他线程再来获取该锁时会发现锁的所有者不是自己而被阻塞挂起。
  • 但是当获取了该锁的线程再次获取锁时发现锁拥有者是自己，就会把计数器值加＋1，当释放锁后计数器值－1 。当计数器值为0 时，锁里面的线程标示被重置为null ， 这时候被阻塞的线程会被唤醒来竞争获取该锁。

但是线程标识、计数器在锁中如何存储的？等到看完 synchronized 的膨胀过程以及MarkWord再说。

抛异常：

  • synchronized 修饰代码块之后，在字节码指令层面，会有覆盖该代码块的异常表 Exception Table，当同步代码块内抛出异常，会执行相应的字节码指令，保证锁能够正常释放。

  • 还可以再追问一下：锁重入之后，内层抛出异常，计数器减一还是直接释放掉锁？

    • 内层抛出异常，能保证内层正常释放掉锁（即计数器减一）。如果该异常在外层捕获并处理，那么并不影响外层，也就是不会导致外层也释放锁。
    public class TestSynchronizedException {
    public static void main(String[] args) {
        Task task = new Task();
        // 两个线程同时执行一个任务
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
    }

	static class Task implements Runnable{
        public synchronized void firstIn(){
            System.out.println(Thread.currentThread().getName() + "第一次进入");
            try {
                secondIn(); // 捕获内层出现的异常
            } catch (Exception e) {
                System.out.println(Thread.currentThread().getName() + e.getMessage());;
            }

			// 等待 1s 之后继续执行外层的代码
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "继续执行");
    	}

        public synchronized void secondIn() throws Exception {
            System.out.println(Thread.currentThread().getName() + "第二次进入");
            throw new Exception("内层异常");
        }

        @Override
        public void run() {
            firstIn();
        }
	}
}
    • 执行结果：
    Thread-0第一次进入
Thread-0第二次进入
Thread-0内层异常
Thread-0继续执行      //可以发现，内层出现异常，如果被捕获并处理，不会导致锁直接被释放
Thread-1第一次进入
Thread-1第二次进入
Thread-1内层异常
Thread-1继续执行

1.4 还使用过其他锁吗？（ReentrantLock）

  • 还使用过 ReentrantLock 可重入锁。
  • 相同点：和 synchronized 一样都是可重入锁 —— 即支持一个线程对资源的重复加锁。
  • 不同点：synchronized 是隐式地获取和释放锁的，而 ReentrantLock 需要显示地获取和释放锁，在锁获取和释放时有更多的可操作性，支持可中断地获取锁、超时获取锁、公平锁，并且可以创建多个条件变量 Condition，实现选择性通知。
  1. 可中断地获取锁：指的是处于阻塞状态等待锁的线程可以被打断等待
  2. **超时获取锁：**等待一段时间，另一线程仍然没有释放锁，那么不再等待 —— 本次获取锁失败
  3. **公平锁：**公平地锁获取，就是等待时间最长的线程最优先获取锁，也可以说锁获取是顺序的，先对锁进行获取请求一定最先满足。

在这里插入图片描述

1.5 ReentrantLock 的实现原理了解吗？（公平锁、可重入、可中断是怎么实现的？）

首先讲AQS

  • 队列同步器 AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者他同步组件的基础框架，它使用了一个 int 成员变量表示同步状态，通过内置的 FIFO 队列来完成资源获取线程的排队工作。
  • AQS 的核心思想是，成功获取同步状态的线程会被设置为当前工作线程，而获取同步状态失败的线程会被加入到同步队列的尾部。

公平锁与非公平锁

  • 公平锁和非公平锁在获取同步状态失败之后，都会进入到 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断同步队列是否有线程，如果有则不去抢锁，被加入到同步队列尾部。

可重入

  • 如果线程获取同步状态时发现 state != 0，即锁已经被占有了，则会去判断当前线程是否是占有锁的线程，如果是，则仍可以获取到 state 并对 state 进行累加操作。

1.6 加锁会带来哪些性能问题？如何解决？

  • 带来的问题主要有：死锁、饥饿、线程切换带来的资源消耗等等。

JAVA并发之加锁导致的活跃性问题

  • 解决：减小资源的消耗方面——synchronized的优化；死锁的避免；饥饿可采用公平锁。

Java中锁的优化
锁的性能影响与优化

2、volatile 有什么作用？

volatile 的第一个语义：

  • Java 中，为了解决内存可见性问题，提供了一种弱形式的同步，也就是使用 volatile 关键字。
  • volatile 可以确保对一个变量的更新对其他线程马上可见。
  • 当一个变量被声明为 volatile 时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。
  • 当其他线程读取该共享变量时，会从主内存中重新获取最新值，而不是使用当前线程的工作内存中的值。
  • volatile 的内存语义和 synchronized 有相似之处 —— 当线程写入了 volatile 变量时就等价于线程退出 synchronized 同步块（把写入工作内存的变量同步到主内存），读取 volatile 变量时就相当于进入同步代码块（先清空本地内存的变量值，再从主内存获取最新值）。

volatile的第二个语义：

  • 禁止指令重排序优化。
  • 普通的变量仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。
  • 例如，在如上代码中，变量c 的值依赖 a 和b 的值，所以重排序后能够保证（ 3 ）的操作在（ 2 ) ( 1 ）之后， 但是（ 1 ) ( 2 ）谁先执行就不一定了，这在单线程下不会存在问题，因为并不影响最终结果。
    int a = 10; (1)
int b = 20; (2)
int c = a + b; (3)
  • 再例如，常见的 DCL 单例模式（代码见文章末尾），如果不加 volatile 修饰，那么在多线程情况下，可能出现t1 线程先将引用地址赋值给了 instance 变量（1），之后才执行构造方程进行初始化（2），但是在 t1 线程执行到（1）时，t2 线程进来发现 instance 已经不为空了，直接返回了该实例，可是此时该实例还并没有初始化完毕。

2.1 原理是什么？

首先说一下 CPU 缓存的相关知识

  • CPU 读取数据的方式（顺序）为

    CPU <------>寄存器 <---->缓存<----->内存

  • 寄存器（register）是 CPU（中央处理器）的组成部分，是一种直接整合到 CPU 中的有限的高速访问速度的存储器。寄存器是一种容量有限的存储器，并且非常小。因此只把一些计算机的指令等一些计算机频繁用到的数据存储在其中，来提高计算机的运行速度。
  • 缓存 Cache ：即高速缓冲存储器，是位于 CPU 与主内存间的一种容量较小但速度很高的存储器。CPU Cache 缓存的是内存数据，用于解决 CPU 处理速度和内存不匹配的问题。现代的 CPU Cache 通常分为三层，分别叫 L1,L2,L3 Cache。（下图转载于 JavaGuide）

接着再说 Java 的内存模型（JMM）

  • 从抽象的角度看，JMM 定义了线程和主内存之间的抽象关系：线程之间的共享变量存储于主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存存储了以读/写共享变量的副本。
  • 本地内存是 JMM 的一个抽象概念，并不真实存在，它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。（Java 内存模型的抽象示意图见下——《Java并发编程艺术》）
    在这里插入图片描述

    计算机硬件底层的内存结构过于复杂，JMM的意义在于避免程序员直接管理计算机底层内存，用一些关键字synchronized、volatile等可以方便的管理内存。

最后来看 volatile 的实现原理

  • 如果对声明了 volatile 的变量进行写操作，JVM 就会向处理器发送一条 Lock 前缀的指令，将这个变量所在的缓存行的数据写回到系统内存。
  • 一个处理器的缓存回写到内存会导致其他处理器的该缓存行无效，当处理器对这个数据进行操作的时候，会重新从系统内存中把数据读到处理器缓存中。

或者说：更底层使用 lock 指令，在对 volatile 变量的读写时加入内存屏障

  • 对 volatile 变量的写指令后会加入写屏障
  • 对 volatile 变量的读指令前会加入读屏障

实现下面的作用：

  • 可见性
    • 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
    • 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据
  • 有序性
    • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
    • 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

2.2 和 synchronized 有什么区别？

  • volatile 关键字是线程同步的轻量级实现，不会引起线程上下文的切换和调度。
  • 但是 volatile 关键字只能用于变量。
  • volatile关键字主要用于解决变量在多个线程之间的可见性，不能保证数据的原子性；
  • synchronized 关键字两者都能保证。

3. 写一个单例模式

public class Singleton{
	private static volatile Singleton instance;
	// 构造方法私有化
	private Singleton(){}
	
	public static Singleton getInstance(){
		if(instance == null){
			synchronized(Singleton.class){
				if(instance == null){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}
Q_P777
关注
专栏目录
Java面试题：谈谈Java中的死锁问题，如何避免和解决死锁？
码农超哥的博客
05-17 425
死锁是多线程编程中的一个经典问题，它发生在两个或多个线程被无限期地阻塞，且无法继续执行的情况。死锁发生时，因为线程相互等待对方持有的资源，但没有一个线程能够向前推进，导致程序无法正常运行。
java中锁的面试题
m0_67401270的博客
06-24 1201
synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。synchronized被称为“重量级的锁”方式，也是“悲观锁”——效率比较低。b.同步方法:Lock锁也称同步锁，加锁与释放锁方法化了，如下：:加同步锁。:释放同步锁。synchronized 是JVM层面的锁，是Java关键字，通过monitor对
Java——各种锁机制详解+面试题合集
最新发布
s13073660520的博客
08-14 691
偏向锁偏向于第一个获取它的线程，如果在接下来的执行过程中，该锁一直没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。在并发环境中，每个线程会先查看此锁维护的等待队列，如果当前队列为空，则占有锁，如果等待队列不为空，则加入到等待队列的末尾，按照FIFO的原则从队列中拿到线程，然会占有锁。再次获取锁的时候，识别获取锁的线程是否为当前占据锁的线程，如果是，再次获取成功后，进行计数自增，释放锁的时候，进行计数自减。缺点：如果程序中大多数的锁总是被多个不同的线程访问，那偏向锁就是多余的。
Java锁常见面试题
长江七号的博客
11-04 1818
在Java中的锁主要是用于保障线程在多并发的情况下数据的一致性。就是实现并发的原子性。不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。如果没有外部干预，线程会一直阻塞无法往下执行，这些一直处于相互等待资源的线程就称为死锁线程。
java中的锁面试题
libaowenBlog的博客
06-18 1万+
synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。锁的升
面试题：Java锁机制
abc123mma的博客
02-11 1748
java锁机制详解
java锁机制的面试题
那些年的代码
04-18 2533
1、ABA问题 CAS 会导致“ABA问题”。 CAS 算法实现一个重要前提需要取出内存中某时刻的数据，而在下时刻比较并替换，那么在这个时间差类会导致数据的变化。 比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且 two 进行了一些操作变成了 B，然后 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操作发现内存中...
Java全能学习面试手册——Java面试题库.zip
10-01
Java全能学习面试手册——Java面试题库.zip 01 7道消息队列ActiveMQ面试题！.pdf 02 10道Java高级必备的Netty面试题！.pdf 03 10道Java面试必备的设计模式面试题！.pdf 04 10个Java经典的List面试题！.pdf 05 10个...
《JAVA面试题》--程序员代码面试指南——Java源代码.zip
04-02
十余年JAVA从业经验，精通JAVA技术体系，有志于做JAVA技能提升的朋友可与我联系，交个朋友 十余年JAVA从业经验，精通JAVA技术体系，有志于做JAVA技能提升的朋友可与我联系，交个朋友 十余年JAVA从业经验，精通JAVA...
2021Java大厂面试题——大厂真题之银盛支付-Java中级.pdf
01-29
大厂真题之银盛支付-Java中级.pdf
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7449
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
java并发锁面试知识
03-21
java中的乐观锁与悲观锁，synchronized与ReentrantLock重入锁的说明与比较
Java缓存面试题——Redis应用
热门推荐
二蛋的博客
02-23 1万+
1、为什么要使用Redis做缓存？2、为什么Redis单线程模型效率也能那么高？3、Redis6.0为什么要引入多线程呢？4、Redis常见数据结构以及使用场景字符串（String）哈希(Hash)列表（list）集合（set）有序集合（ZSET）5、pipeline有什么好处，为什么要用pipeline？6、Redis官方为什么不提供Windows版本？7、Redis持久化方式有哪些？以及有什么区别？RDBAOF8、什么是Redis事务？原理是什么？9、如何在100个亿URL中快速判断某URL是否存在？传
Java中有关锁的面试题
qq_36828822的博客
08-30 1709
sychronized修饰普通方法和静态方法的区别？什么是可见性? 对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。 但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，类锁其实锁的是每个类的对应的class对象。类锁和对象锁之间也是互不干扰的。 可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其
Java锁相关面试题
daitu__的博客
01-11 562
Synchronized对象存储
java 关于锁常见面试题
那些年的代码
04-19 346
1、synchronized作用于静态方法和非静态方法的区别 非静态方法： 给对象加锁(可以理解为给这个对象的内存上锁,注意 只是这块内存,其他同类对象都会有各自的内存锁),这时候在其他一个以上线程中执行该对象的这个同步方法(注意:是该对象)就会产生互斥 静态方法: 相当于在类上加锁(*.class 位于代码区,静态方法位于静态区域,这个类产生的对象公用这个静态方法,所以这块内存，N个对象...
java 锁 面试题_java锁的常见面试题
weixin_39724889的博客
02-12 626
wait()该方法用来将当前线程置入休眠状态，直到接到通知或被中断为止。在调用 wait()之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用 wait()方法。进入 wait()方法后，当前线程释放锁。在从 wait()返回前，线程与其他线程竞争重新获得锁。如果调用 wait()时，没有持有适当的锁，则抛出 IllegalMonitorStateException，它是 Ru...
java锁的概念_java中锁的概念介绍
weixin_39737111的博客
02-18 446
我们在学习进程或是多线程的时候，经常会说到线程安全的问题。那么保证其安全的方法，很常见的操作就是在其中用到了锁。这里很多人都见过锁，一般来说主要有synchronize和Lock。下面我们就锁的概念、作用、类型，以及不同类型的区别带来详解的介绍，一起往下看具体内容。一、锁的概念及作用锁主要用来实现资源共享的同步。只有获取到了锁才能访问该同步代码，否则等待其他线程使用结束释放锁。二、锁的类型这里主要...
Java面试---锁
Guo_Liwei的博客
07-14 1262
常见锁以及阻塞队列的使用（生产者消费者问题）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值