面试问题浓缩总结
小游
2021-03-23

面试题

# 同学的一次面试

# 内存溢出的两种问题及原因

# java.lang.OutOfMemoryError

方法区主要存储类的元信息，实现在元数据区。当JVM发现元数据区没有足够的空间分配给加载的类时，抛出该异常。

# java.lang.StackOverflowError

抛出这个错误表明应用程序因为深递归导致栈被耗尽了。每当java程序启动一个新的线程时，java虚拟机会为他分配一个栈，java栈以帧为单位保持线程运行状态；当线程调用一个方法是，jvm压入一个新的栈帧到这个线程的栈中，只要这个方法还没返回，这个栈帧就存在。 如果方法的嵌套调用层次太多(如递归调用),随着java栈中的帧的增多，最终导致这个线程的栈中的所有栈帧的大小的总和大于-Xss设置的值，而产生生StackOverflowError溢出异常。

# 内存模型主要要回收那些类

不再使用的对象需要进行回收，不使用的类也有可能回收。

# 如何查看GC状态

使用jstat命令，（jstat [Options] vmid [interval] [count]）

参数说明

Options，选项，我们一般使用 -gcutil 查看gc情况 vmid，VM的进程号，即当前运行的java进程号 interval，间隔时间，单位为秒或者毫秒 count，打印次数，如果缺省则打印无数次

比如下面这里我们打印12538进程的GC情况

image.png

使用阿里开源的Arthas

参考

  1. Linux使用jstat命令查看jvm的GC情况_zlzlei的专栏-CSDN博客 (opens new window)
  2. 推荐一款阿里开源的 Java 诊断工具，好用到爆！ - SegmentFault 思否 (opens new window)

# Bean是线程安全的吗

容器本身并没有提供Bean的线程安全策略，因此可以说Spring容器中的Bean本身不具备线程安全的特性，但是我们还需要结合不同的Bean进行研究

Spring 的 bean 作用域（scope）类型有5种：

1、singleton:单例，默认作用域。

2、prototype:原型，每次创建一个新对象。

3、request:请求，每次Http请求创建一个新对象，适用于WebApplicationContext环境下。

4、session:会话，同一个会话共享一个实例，不同会话使用不用的实例。

5、global-session:全局会话，所有会话共享一个实例。

Spring中的Bean默认是单例模式的，框架并没有对bean进行多线程的封装处理。实际上大部分时间Bean是无状态的（比如Dao） 所以说在某种程度上来说Bean其实是安全的。

参考： 面试：Spring 中的bean 是线程安全的吗？ - 云+社区 - 腾讯云 (tencent.com) (opens new window)

# Sleep(0)可以干嘛

Thread.Sleep(0) 并非是真的要线程挂起0毫秒，意义在于这次调用Thread.Sleep(0)的当前线程确实的被冻结了一下，让其他线程有机会优先执行。Thread.Sleep(0) 是你的线程暂时放弃cpu，也就是释放一些未用的时间片给其他线程或进程使用，就相当于一个让位动作。

Sleep(0)的妙用_HawkJony的博客-CSDN博客 (opens new window)

# 大佬的面试题

# 堆分析器

使用MAT来进行分析

Java堆分析器 - Eclipse Memory Analyzer Tool(MAT)_旧路-CSDN博客_java mat (opens new window)

# 静态变量什么时候会被回收

静态成员一般也可以分为静态基本类型和静态引用类型。

静态基本类型存储在在静态变量区域；静态引用类型的引用存储在静态变量区域，而实例（具体内容）存储在堆上。静态成员只存在一份，静态成员加载时机：类加载的时候（第一次访问），这个类中所有静态成员就会被加载在静态存储区，同时存储在静态变量区域的成员一旦创建，直到程序退出才会被回收 (opens new window)。（注：如果是引用类型，如static student myst=new student()，myst=null这时候，在静态存储区里面存的是一个地址（myst），这个地址指向在堆里面创建的student实例对象，当myst=null的时候，在静态存储区里面的变量会一直存在，但是在堆里面的student实例对象因为没有变量指向它，所以会被回收）。因此如果不用的静态引用类型可以通过设置=null方式让GC可以回收其堆上的空间。

# 知乎上看到的

# 对象如何进行深拷贝，除了clone

特地谷歌了一下，发现居然还有很多方法

  1. 使用构造函数进行深拷贝
  2. 重载clone方法
  3. 使用Apache Commons Lang进行序列化
  4. 使用Gson序列化
  5. 使用Jackson序列化

Java如何对一个对象进行深拷贝？ - 吴大山的博客 | Wudashan Blog (opens new window)

# happen-before原则

这个是java内存模型里的，具体参考

JVM模型 | 面试问题浓缩总结 (xiaoyou66.com) (opens new window)

# 单例对象会被jvm的gc时回收吗

java中单例模式创建的对象被自己类中的静态属性所引用，符合第二条，因此，单例对象不会被jvm垃圾收集。

Java中单例对象不会被GC回收_qq876551724的博客-CSDN博客 (opens new window)

# wait()与sleep()的区别

简单来说wait()会释放对象锁而sleep()不会释放对象锁

# Synchronized(obj){...}是锁对象还是代码块？

锁的的是对象，因为会修改对象里面的内容

阿里面试题深度解析：Synchronized(obj){...}是锁对象还是代码块？Why？_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili (opens new window)

# 如何分析并找出内存泄漏的位置

  • 在java运行程序的时候，我们可以加入 -XX:+HeapDumpOnOutOfMemoryError 参数，可以生成dump文件，然后当程序抛出异常后，在程序的classpath下会生成以一个以.hprof结尾的文件，我们可以使用 IBM heapAnalyzer 来分析head dump文件，并进行排查

  • Java VisualVM远程分析堆

    就是这个工具，这个工具可以查看详细的内存信息

    image-20210407170434600

参考：

# java什么情况下会导致内存泄漏

内存泄漏的表现：

  • 应用程序长时间连续运行时性能严重下降；
  • 应用程序中的OutOfMemoryError堆错误；
  • 自发且奇怪的应用程序崩溃；
  • 应用程序偶尔会耗尽连接对象；

导致内存泄漏的原因

  • 未关闭的资源导致内存泄漏

    每当创建连接或者打开流时，JVM都会为这些资源分配内存。如果没有关闭连接，会导致持续占有内存。在任意情况下，资源留下的开放连接都会消耗内存，如果不处理，就会降低性能，甚至OOM。

    解决办法：使用finally块关闭资源；关闭资源的代码，不应该有异常；JDK1.7之后，可以使用太try-with-resource块。

  • 不正确的equals()和hashCode()

在HashMap和HashSet这种集合中，常常用到equal()和hashCode()来比较对象，如果重写不合理，将会成为潜在的内存泄漏问题。

解决办法：用最佳的方式重写equals()和hashCode().

  • 引用了外部类的内部类

    非静态内部类的初始化，总是需要外部类的实例；默认情况下，每个非静态内部类都包含对其外部类的隐式引用，如果我们在应用程序中使用这个内部类对象，那么即使在我们的外部类对象超出范围后，它也不会被垃圾收集器清除掉。

    解决办法：如果内部类不需要访问外部类包含的类成员，可以转换为静态类。

  • finalize方法导致的内存泄漏

    重写finalize()方法时，该类的对象不会立即被垃圾收集器收集，如果finalize()方法的代码有问题，那么会潜在的印发OOM；

    解决办法：避免重写finalize()方法。

  • 使用ThreadLocal造成内存泄漏

    使用ThreadLocal时，每个线程只要处于存活状态就可保留对其ThreadLocal变量副本的隐式调用，且将保留其自己的副本。使用不当，就会引起内存泄漏。

    一旦线程不再存在，该线程的threadLocal对象就应该被垃圾收集，而现在线程的创建都是使用线程池，线程池有线程重用的功能，因此线程就不会被垃圾回收器回收。所以使用到ThreadLocal来保留线程池中的线程的变量副本时，ThreadLocal没有显式地删除时，就会一直保留在内存中，不会被垃圾回收。

    解决办法：不再使用ThreadLocal时，调用remove()方法，该方法删除了此变量的当前线程值。不要使用ThreadLocal.set(null)，它只是查找与当前线程关联的Map并将键值中这个threadLocal对象所对应的值为null，并没有清除这个键值对。

参考：

# javaGuide上收集的

JavaGuide (gitee.io) (opens new window)

# import java 和 javax 有什么区别？

刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准 API 的一部分。

所以，实际上 java 和 javax 没有区别。这都是一个名字。

# 说说 sleep 方法和 wait 方法区别和共同点

  • 两者最主要的区别在于：sleep() 方法没有释放锁，而 wait() 方法释放了锁 。
  • 两者都可以暂停线程的执行。
  • wait() 通常被用于线程间交互/通信，sleep()通常被用于暂停执行。
  • wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify()或者 notifyAll() 方法。sleep()方法执行完成后，线程会自动苏醒。或者可以使用 wait(long timeout) 超时后线程会自动苏醒。

# 为什么我们调用-start-方法时会执行-run-方法，为什么我们不能直接调用-run-方法？

这是另一个非常经典的 java 多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！

new 一个 Thread，线程进入了新建状态。调用 start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。 但是，直接执行 run() 方法，会把 run() 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结： 调用 start() 方法方可启动线程并使线程进入就绪状态，直接执行 run() 方法的话不会以多线程的方式执行。

# 牛客网上收集的

# 用java来实现生产者消费者模型

多线程必考的「生产者 - 消费者」模型，看齐姐这篇文章就够了 - SegmentFault 思否 (opens new window)

# OOM问题产生原因以及如何解决

# Java heap space

当堆内存（Heap Space）没有足够空间存放新创建的对象时，就会抛出 java.lang.OutOfMemoryError:Javaheap space 错误（根据实际生产经验，可以对程序日志中的 OutOfMemoryError 配置关键字告警，一经发现，立即处理）。

原因分析

Javaheap space 错误产生的常见原因可以分为以下几类：

1、请求创建一个超大对象，通常是一个大数组。

2、超出预期的访问量/数据量，通常是上游系统请求流量飙升，常见于各类促销/秒杀活动，可以结合业务流量指标排查是否有尖状峰值。

3、过度使用终结器（Finalizer），该对象没有立即被 GC。

4、内存泄漏（Memory Leak），大量对象引用没有释放，JVM 无法对其自动回收，常见于使用了 File 等资源没有回收。

解决方案

针对大部分情况，通常只需要通过 -Xmx 参数调高 JVM 堆内存空间即可。如果仍然没有解决，可以参考以下情况做进一步处理：

1、如果是超大对象，可以检查其合理性，比如是否一次性查询了数据库全部结果，而没有做结果数限制。

2、如果是业务峰值压力，可以考虑添加机器资源，或者做限流降级。

3、如果是内存泄漏，需要找到持有的对象，修改代码设计，比如关闭没有释放的连接。

# GC overhead limit exceeded

当 Java 进程花费 98% 以上的时间执行 GC，但只恢复了不到 2% 的内存，且该动作连续重复了 5 次，就会抛出 java.lang.OutOfMemoryError:GC overhead limit exceeded 错误。简单地说，就是应用程序已经基本耗尽了所有可用内存， GC 也无法回收。

此类问题的原因与解决方案跟 Javaheap space 非常类似，可以参考上文。

# Permgen space

该错误表示永久代（Permanent Generation）已用满，通常是因为加载的 class 数目太多或体积太大。

原因分析

永久代存储对象主要包括以下几类：

1、加载/缓存到内存中的 class 定义，包括类的名称，字段，方法和字节码；

2、常量池；

3、对象数组/类型数组所关联的 class；

4、JIT 编译器优化后的 class 信息。

PermGen 的使用量与加载到内存的 class 的数量/大小正相关。

解决方案

根据 Permgen space 报错的时机，可以采用不同的解决方案，如下所示：

1、程序启动报错，修改 -XX:MaxPermSize 启动参数，调大永久代空间。

2、应用重新部署时报错，很可能是没有应用没有重启，导致加载了多份 class 信息，只需重启 JVM 即可解决。

3、运行时报错，应用程序可能会动态创建大量 class，而这些 class 的生命周期很短暂，但是 JVM 默认不会卸载 class，可以设置 -XX:+CMSClassUnloadingEnabled 和 -XX:+UseConcMarkSweepGC这两个参数允许 JVM 卸载 class。

如果上述方法无法解决，可以通过 jmap 命令 dump 内存对象 jmap-dump:format=b,file=dump.hprof<process-id> ，然后利用 Eclipse MAT https://www.eclipse.org/mat 功能逐一分析开销最大的 classloader 和重复 class。

# Metaspace

JDK 1.8 使用 Metaspace 替换了永久代（Permanent Generation），该错误表示 Metaspace 已被用满，通常是因为加载的 class 数目太多或体积太大。

此类问题的原因与解决方法跟 Permgenspace 非常类似，可以参考上文。需要特别注意的是调整 Metaspace 空间大小的启动参数为 -XX:MaxMetaspaceSize。

# Unable to create new native thread

每个 Java 线程都需要占用一定的内存空间，当 JVM 向底层操作系统请求创建一个新的 native 线程时，如果没有足够的资源分配就会报此类错误。

原因分析

JVM 向 OS 请求创建 native 线程失败，就会抛出 Unableto createnewnativethread，常见的原因包括以下几类：

1、线程数超过操作系统最大线程数 ulimit 限制；

2、线程数超过 kernel.pid_max（只能重启）；

3、native 内存不足；

该问题发生的常见过程主要包括以下几步：

1、JVM 内部的应用程序请求创建一个新的 Java 线程；

2、JVM native 方法代理了该次请求，并向操作系统请求创建一个 native 线程；

3、操作系统尝试创建一个新的 native 线程，并为其分配内存；

4、如果操作系统的虚拟内存已耗尽，或是受到 32 位进程的地址空间限制，操作系统就会拒绝本次 native 内存分配；

5、JVM 将抛出 java.lang.OutOfMemoryError:Unableto createnewnativethread 错误。

解决方案

1、升级配置，为机器提供更多的内存；

2、降低 Java Heap Space 大小；

3、修复应用程序的线程泄漏问题；

4、限制线程池大小；

5、使用 -Xss 参数减少线程栈的大小；

6、调高 OS 层面的线程最大数：执行 ulimia-a 查看最大线程数限制，使用 ulimit-u xxx 调整最大线程数限制。

ulimit -a .... 省略部分内容 ..... max user processes (-u) 16384

# Out of swap space？

该错误表示所有可用的虚拟内存已被耗尽。虚拟内存（Virtual Memory）由物理内存（Physical Memory）和交换空间（Swap Space）两部分组成。当运行时程序请求的虚拟内存溢出时就会报 Outof swap space? 错误。

原因分析

该错误出现的常见原因包括以下几类：

1、地址空间不足；

2、物理内存已耗光；

3、应用程序的本地内存泄漏（native leak），例如不断申请本地内存，却不释放。

4、执行 jmap-histo:live<pid> 命令，强制执行 Full GC；如果几次执行后内存明显下降，则基本确认为 Direct ByteBuffer 问题。

解决方案

根据错误原因可以采取如下解决方案：

1、升级地址空间为 64 bit；

2、使用 Arthas 检查是否为 Inflater/Deflater 解压缩问题，如果是，则显式调用 end 方法。

3、Direct ByteBuffer 问题可以通过启动参数 -XX:MaxDirectMemorySize 调低阈值。

4、升级服务器配置/隔离部署，避免争用。

# Kill process or sacrifice child

有一种内核作业（Kernel Job）名为 Out of Memory Killer，它会在可用内存极低的情况下“杀死”（kill）某些进程。OOM Killer 会对所有进程进行打分，然后将评分较低的进程“杀死”，具体的评分规则可以参考 Surviving the Linux OOM Killer。

不同于其他的 OOM 错误， Killprocessorsacrifice child 错误不是由 JVM 层面触发的，而是由操作系统层面触发的。

原因分析

默认情况下，Linux 内核允许进程申请的内存总量大于系统可用内存，通过这种“错峰复用”的方式可以更有效的利用系统资源。

然而，这种方式也会无可避免地带来一定的“超卖”风险。例如某些进程持续占用系统内存，然后导致其他进程没有可用内存。此时，系统将自动激活 OOM Killer，寻找评分低的进程，并将其“杀死”，释放内存资源。

解决方案

1、升级服务器配置/隔离部署，避免争用。

2、OOM Killer 调优。

# Requested array size exceeds VM limit

JVM 限制了数组的最大长度，该错误表示程序请求创建的数组超过最大长度限制。

JVM 在为数组分配内存前，会检查要分配的数据结构在系统中是否可寻址，通常为 Integer.MAX_VALUE-2。

此类问题比较罕见，通常需要检查代码，确认业务是否需要创建如此大的数组，是否可以拆分为多个块，分批执行。

# Direct buffer memory

Java 允许应用程序通过 Direct ByteBuffer 直接访问堆外内存，许多高性能程序通过 Direct ByteBuffer 结合内存映射文件（Memory Mapped File）实现高速 IO。

原因分析

Direct ByteBuffer 的默认大小为 64 MB，一旦使用超出限制，就会抛出 Directbuffer memory 错误。

解决方案

1、Java 只能通过 ByteBuffer.allocateDirect 方法使用 Direct ByteBuffer，因此，可以通过 Arthas 等在线诊断工具拦截该方法进行排查。

2、检查是否直接或间接使用了 NIO，如 netty，jetty 等。

3、通过启动参数 -XX:MaxDirectMemorySize 调整 Direct ByteBuffer 的上限值。

4、检查 JVM 参数是否有 -XX:+DisableExplicitGC 选项，如果有就去掉，因为该参数会使 System.gc() 失效。

5、检查堆外内存使用代码，确认是否存在内存泄漏；或者通过反射调用 sun.misc.Cleaner 的 clean() 方法来主动释放被 Direct ByteBuffer 持有的内存空间。

6、内存容量确实不足，升级配置。

教你分析9种 OOM 常见原因及解决方案 - 云+社区 - 腾讯云 (tencent.com) (opens new window)

# string 从 "abc" 到 "abcd"，如何分配内存的

string是不可以修改的，所以我们堆string进行加操作时操作系统会新创建一个对象然后修改对象引用

String s1 = "abc"; s1 += "d"; System.out.println(s1); // "abcd" // 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

# string 和 []byte 如何转换

String转byte[]，就是先转ASCII码（可能还有GBK或者utf-8），然后再转成二进制，如，A->65->65的二进制表示.

# while(tree) {sleep(1)} 是干嘛的

网上找的相关资料说使用sleep可以让线程休眠，避免占用CPU资源

# 自己面试遇到的

# 面向对象三大特性六大原则

面向对象的三大特性是"封装、"多态"、"继承"，五大原则是"单一职责原则"、"开放封闭原则"、"里氏替换原则"、"依赖倒置原则"、"接口分离原则"、"迪米特原则（高内聚低耦合）"。

单一职责原则SRP(Single Responsibility Principle)

是指一个类的功能要单一，不能包罗万象。

开放封闭原则OCP(Open－Close Principle)

一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的

里式替换原则LSP(the Liskov Substitution Principle LSP)

子类应当可以替换父类并出现在父类能够出现的任何地方。

依赖倒置原则DIP(the Dependency Inversion Principle DIP)

A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。

B.抽象不应该依赖于具体实现，具体实现应该依赖于抽象。

具体依赖抽象，上层依赖下层。高层模块就是调用端，底层模块就是具体实现类。（应该让底层模块定义抽象接口并且实现，让高层模块调用抽象接口，而不是直接调用实现类。）

接口分离原则ISP(the Interface Segregation Principle ISP)

模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来，即面向接口编程。（提供接口，给其他模块调用）

迪米特法则（Law of Demeter,简称LoD）

通俗来讲：一个类对自己依赖的类知道的越少越好。自从我们接触编程开始，就知道了软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。

1.面向对象三大特性六大原则_郑学炜的技术博客-CSDN博客 (opens new window)

# 什么是多态？多态怎么实现？

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作

多态存在的必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象：Parent p = new Child();

多态通常有两种实现方法：

  1. 子类继承父类（extends）可以重载或者重写
  2. 类实现接口（implements）
  3. 抽象类或者抽象方法

# java定时任务实现方式

# JDK 自带的定时器实现

这个类允许你调度一个java.util.TimerTask任务。主要有以下几个方法：

schedule(TimerTask task, long delay) 延迟 delay 毫秒 执行

schedule(TimerTask task, Date time) 特定时间執行

schedule(TimerTask task, long delay, long period) 延迟 delay 执行并每隔period 执行一次

# Quartz 定时器实现

Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。

Quartz允许开发人员根据时间间隔来调度作业。它实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。可以动态的添加删除定时任务，另外很好的支撑集群调度。简单地创建一个org.quarz.Job接口的Java类。

# Spring 相关的任务调度

Spring 3.0+ 自带的任务调度实现，主要依靠TaskScheduler接口的几个实现类实现。删除和修改任务比较麻烦。 主要用法有三种： Spring配置文件实现、注解实现、代码动态添加

Java 定时任务的几种实现方式_好习惯要坚持下去-CSDN博客_java定时任务 (opens new window)

编辑 (opens new window)
上次更新: 2021/04/24, 10:38:20
java8特性
其他

← 其他→

Theme by Vdoing | Copyright © 2021-2021 小游