JVM-内存模型

1.JVM的内存模型介绍一下？

根据 JDK 8 规范，JVM 运行时内存共分为虚拟机栈、堆、元空间、程序计数器、本地方法栈五个部分。

JVM的内存结构主要分为以下几个部分：

1. 程序计数器：可以看作是当前线程所执行的字节码的行号指示器，用于存储当前线程正在执行的 Java 方法的 JVM 指令地址。如果线程执行的是 Native 方法，计数器值为 null。是唯一一个在 Java 虚拟机规范中没有规定任何 OutOfMemoryError 情况的区域，生命周期与线程相同。
2. Java 虚拟机栈：每个线程都有自己独立的 Java 虚拟机栈，生命周期与线程相同。每个方法在执行时都会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。可能会抛出StackOverflowError 和 OutOfMemoryError 异常。
3. 本地方法栈：与 Java 虚拟机栈类似，主要为虚拟机使用到的 Native 方法服务，在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。本地方法执行时也会创建栈帧，同样可能出现 StackOverflowError 和OutOfMemoryError 两种错误。
4. Java 堆：是 JVM 中最大的一块内存区域，被所有线程共享，在虚拟机启动时创建，用于存放对象实例。从内存回收角度，堆被划分为新生代和老年代，新生代又分为 Eden 区和两个 Survivor 区（FromSurvivor 和 To Survivor）。如果在堆中没有内存完成实例分配，并且堆也无法扩展时会抛出 OutOfMemoryError 异常。
5. 方法区（元空间）：在 JDK 1.8 及以后的版本中，方法区被元空间取代，使用本地内存。用于存储已被虚拟机加载的类信息、常量、静态变量等数据。虽然方法区被描述为堆的逻辑部分，但有 "非堆" 的别名。方法区可以选择不实现垃圾收集，内存不足时会抛出 OutOfMemoryError 异常。
6. 运行时常量池：是方法区的一部分，用于存放编译期生成的各种字面量和符号引用，具有动态性，运行时也可将新的常量放入池中。当无法申请到足够内存时，会抛出 OutOfMemoryError 异常。
7. 直接内存：不属于 JVM 运行时数据区的一部分，通过 NIO 类引入，是一种堆外内存，可以显著提高I/O 性能。直接内存的使用受到本机总内存的限制，若分配不当，可能导致 OutOfMemoryError 异常。

2.JVM内存模型里的堆和栈有什么区别？

1. 用途 ：栈主要用于存储局部变量、方法调用的参数、方法返回地址以及一些临时数据。每当一个方法被调用，一个栈帧（stack frame）就会在栈中创建，用于存储该方法的信息，当方法执行完毕，栈帧也会被移除。堆用于存储对象的实例（包括类的实例和数组）。当你使用new关键字创建一个对象时，对象的实例就会在堆上分配空间。
2. 生命周期：栈中的数据具有确定的生命周期，当一个方法调用结束时，其对应的栈帧就会被销毁，栈中存储的局部变量也会随之消失。堆中的对象生命周期不确定，对象会在垃圾回收机制（GarbageCollection, GC）检测到对象不再被引用时才被回收。
3. 存取速度：栈的存取速度通常比堆快，因为栈遵循先进后出（LIFO, Last In First Out）的原则，操作简单快速。堆的存取速度相对较慢，因为对象在堆上的分配和回收需要更多的时间，而且垃圾回收机制的运行也会影响性能。
4. 存储空间：栈的空间相对较小，且固定，由操作系统管理。当栈溢出时，通常是因为递归过深或局部变量过大。堆的空间较大，动态扩展，由JVM管理。堆溢出通常是由于创建了太多的大对象或未能及时回收不再使用的对象。
5. 可见性：栈中的数据对线程是私有的，每个线程有自己的栈空间。堆中的数据对线程是共享的，所有线程都可以访问堆上的对象。

3.栈中存的到底是指针还是对象？

在JVM内存模型中，栈（Stack） 主要用于管理线程的局部变量和方法调用的上下文，而**堆（Heap）**则是用于存储所有类的实例和数组。

当我们在栈中讨论"存储"时，实际上指的是存储基本类型的数据（如int, double等） 和对象的引用，而不是对象本身。

这里的关键点是，栈中存储的不是 对象，而是对象的引用 。也就是说，当你在方法中声明一个对象，比如 MyObject obj = new MyObject(); ，这里的**obj**实际上是一个存储在栈上的引用，指向堆中实际的对象实例。这个引用是一个固定大小的数据（例如在64位系统上是8字节），它指向堆中分配给对象的内存区域。

4.堆分为哪几部分呢？

Java堆（Heap） 是Java虚拟机（JVM） 中内存管理的一个重要区域，主要用于存放对象实例 和数组。 随着JVM的发展和不同垃圾收集器的实现，堆的具体划分可能会有所不同，但通常可以分为以下几个部分：

1. 新生代（Young Generation） :新生代分为Eden Space 和Survivor Space 。在Eden Space中， 大多数新创建的对象首先存放在这里。Eden区相对较小，当Eden区满 时，会触发一次Minor GC（新生代垃圾回收） 。在Survivor Spaces中，通常分为两个相等大小的区域，称为S0（Survivor 0）和S1（Survivor 1）。在每次Minor GC后，存活下来的对象会被移动到其中一个Survivor空间，以继续它们的生命周期。这两个区域轮流充当对象的中转站，帮助区分短暂存活的对象和长期存活的对象。
2. 老年代（Old Generation/Tenured Generation） :存放过一次 或多次Minor GC仍存活的对象会被移动到老年代。老年代中的对象生命周期较长，因此Major GC（也称为Full GC，涉及老年代的垃圾回收）发生的频率相对较低，但其执行时间通常比Minor GC长。老年代的空间通常比新生代大，以存储更多的长期存活对象。
3. 元空间（Metaspace） :从Java 8开始，永久代（Permanent Generation）被元空间取代，用于存储类的元数据信息，如类的结构信息（如字段、方法信息等）。元空间并不在Java堆中，而是使用本地内存，这解决了永久代容易出现的内存溢出问题。
4. 大对象区（Large Object Space / Humongous Objects） :在某些JVM实现中（如G1垃圾收集器），为大对象分配了专门的区域，称为大对象区或Humongous Objects区域。大对象是指需要大量连续内存空间的对象，如大数组。这类对象直接分配在老年代，以避免因频繁的年轻代晋升而导致的内存碎片化问题。

5.如果有个大对象一般是在哪个区域？

大对象通常会直接分配到老年代 。新生代主要用于存放生命周期较短 的对象，并且其内存空间相对较小。 如果将大对象分配到新生代，可能会很快导致新生代空间不足，从而频繁触发 Minor GC。而每次 Minor GC 都需要进行对象的复制和移动操作，这会带来一定的性能开销。将大对象直接分配到老年代，可以减少新生代的内存压力，降低 MinorGC 的频率。

大对象通常需要连续的内存空间，如果在新生代中频繁分配和回收大对象，容易产生内存碎片，导致后续分配大对象时可能因为内存不连续而失败。老年代的空间相对较大，更适合存储大对象，有助于减少内存碎片的产生。

6.程序计数器的作用，为什么是私有的？

Java程序是支持多线程 一起运行的，多个线程一起运行的时候cpu会有一个调动器组件给它们分配时间片，比如说会给线程1分给一个时间片，它在时间片内如果它的代码没有执行完，它就会把线程1的状态执行一个暂存，切换到线程2去，执行线程2的代码，等线程2的代码执行到了一定程度，线程2的时间片用完了，再切换回来，再继续执行线程1剩余部分的代码。

我们考虑一下，如果在线程切换的过程中，下一条指令执行到哪里了，是不是还是会用到我们的程序计数器 啊。每个线程都有自己的程序计数器，因为它们各自执行的代码的指令地址 是不一样的呀，所以每个线程 都应该有自己的程序计数器。

7.方法区中的方法的执行过程？

1. 当程序中通过对象或类直接调用某个方法时，主要包括以下几个步骤：
2. 解析方法调用：JVM会根据方法的符号引用找到实际的方法地址（如果之前没有解析过的话）。
3. 栈帧创建：在调用一个方法前，JVM会在当前线程的Java虚拟机栈中为该方法分配一个新的栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。
4. 执行方法：执行方法内的字节码指令，涉及的操作可能包括局部变量的读写、操作数栈的操作、跳转控制、对象创建、方法调用等。
5. 返回处理：方法执行完毕后，可能会返回一个结果给调用者，并清理当前栈帧，恢复调用者的执行环境。

8.方法区中还有哪些东西？

它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等。

1. **类信息：**包括类的结构信息、类的访问修饰符、父类与接口等信息。
2. **常量池：**存储类和接口中的常量，包括字面值常量、符号引用，以及运行时常量池。
3. **静态变量：**存储类的静态变量，这些变量在类初始化的时候被赋值。
4. **方法字节码：**存储类的方法字节码，即编译后的代码。
5. **符号引用：**存储类和方法的符号引用，是一种直接引用不同于直接引用的引用类型。
6. **运行时常量池：**存储着在类文件中的常量池数据，在类加载后在方法区生成该运行时常量池。
7. **常量池缓存：**用于提升类加载的效率，将常用的常量缓存起来方便使用。

9.String保存在哪里呢？

String 保存在字符串常量池中，不同于其他对象，它的值是不可变 的，且可以被多个引用共享。

10.String s = new String（"abc"）执行过程中分别对应哪些内存区域？

这个代码中有一个new 关键字，我们知道new 指令是创建一个类的实例对象并完成加载初始化的，因此这个字符串对象是在运行期 才能确定的，创建的字符串对象是在堆内存上。

在String的构造方法中传递了一个字符串abc，由于这里的abc是被final修饰的属性所以它是一个字符串常量。在首次构建这个对象时，JVM拿字面量"abc"去字符串常量池试图获取其对应String对象的引用。于是在堆中创建了一个"abc"的String对象，并将其引用保存到字符串常量池中，然后返回；

所以，如果abc这个字符串常量不存在，则创建两个对象，分别是abc这个字符串常量，以及new String这个实例对象。如果abc这字符串常量存在，则只会创建一个对象。

11引用类型有哪些？有什么区别?

引用类型主要分为强软弱虚四种：

1. 强引用指的就是代码中普遍存在的赋值方式，比如A a = new A()。强引用关联的对象，永远不会被GC回收。
2. 软引用 可以用SoftReference来描述，指的是那些有用但是不是必须要的对象。系统在发生内存溢出前会对这类引用的对象进行回收。
3. 弱引用 可以用WeakReference来描述，他的强度比软引用更低一点，弱引用的对象下一次GC的时候一定会被回收，而不管内存是否足够。
4. 虚引用也被称作幻影引用，是最弱的引用关系，可以用PhantomReference来描述，他必须和ReferenceQueue一起使用，同样的当发生GC的时候，虚引用也会被回收。可以用虚引用来管理堆外内存。

12弱引用了解吗?举例说明在哪里可以用?

Java中的弱引用是一种引用类型，它不会阻止一个对象被垃圾回收。弱引用是通过**Java.lang.ref.WeakReference** 类实现的。弱引用的一个主要用途是创建非强制性的对象引用，这些引用可以在内存压力大时被垃圾回收器清理，从而避免内存泄露。

弱引用的使用场景：

1. 缓存系统：弱引用常用于实现缓存，特别是当希望缓存项能够在内存压力下自动释放时。如果缓存的大不受控制，可能会导致内存溢出。使用弱引用来维护缓存，可以让JVM在需要更多内存时自动清理这些缓存对象。
2. 对象池：在对象池中，弱引用可以用来管理那些暂时不使用的对象。当对象不再被强引用时，它们可以被垃圾回收，释放内存。
3. 避免内存泄露：当一个对象不应该被长期引用时，使用弱引用可以防止该对象被意外地保留，从而避免潜在的内存泄露。

示例代码：

一个缓存系统，我们使用弱引用来维护缓存中的对象：

使用**WeakReference** 来存储**MyHeavyObject**实例，当内存压力增大时，垃圾回收器可以自由地回收这些对象，而不会影响缓存的正常运行。

如果一个对象被垃圾回收，下次尝试从缓存中获取时，get()方法会返回null，这时我们可以重新创建对象并将其放入缓存中。因此，使用弱引用时要注意，一旦对象被垃圾回收，通过弱引用获取的对象可能会变为null，因此在使用前通常需要检查这一点。

13.内存泄漏和内存溢出的理解？

**内存泄露：**内存泄漏是指程序在运行过程中不再使用的对象仍然被引用，而无法被垃圾收集器回收，从而导致可用内存逐渐减少。在Java中，垃圾回收机制会自动回收不再使用的对象，但如果有对象仍被不再使用的引用持有，垃圾收集器无法回收这些内存，最终可能导致程序的内存使用不断增加。

内存泄露常见原因：

1. 静态集合 ：使用静态数据结构（如HashMap或ArrayList）存储对象，且未清理。
2. 事件监听：未取消对事件源的监听，导致对象持续被引用。
3. 线程：未停止的线程可能持有对象引用，无法被回收。
4. 内存溢出： 内存溢出是指Java虚拟机（JVM）在申请内存时，无法找到足够的内存，最终引发**OutOfMemoryError**。这通常发生在堆内存不足以存放新创建的对象时。

内存溢出常见原因：

1. 大量对象创建：程序中不断创建大量对象，超出JVM堆的限制。
2. 持久引用：大型数据结构（如缓存、集合等）长时间持有对象引用，导致内存累积。
3. 递归调用：深度递归导致栈溢出。

14.jvm 内存结构有哪几种内存溢出的情况？

1. 堆内存溢出 ：当出现Java.lang.OutOfMemoryError:Java heap space 异常时，就是堆内存溢出了。**原因：**代码中可能存在大对象分配，或者发生了内存泄露，导致在多次GC之后，还是无法找到一块足够大的内存容纳当前对象。
2. 栈溢出 ：如果我们写一段程序不断的进行递归调用，而且没有退出条件，就会导致不断地进行压栈。类似这种情况，JVM 实际会抛出 StackOverFlowError ；当然，如果 JVM 试图去扩展栈空间的的时候失败，则会抛出 OutOfMemoryError。
3. 元空间溢出 ：元空间的溢出，系统会抛出Java.lang.OutOfMemoryError: Metaspace。 **原因：**系统的代码非常多或引用的第三方包非常多或者通过动态代码生成类加载等方法，导致元空间的内存占用很大。
4. 直接内存内存溢出 ：在使用ByteBuffer 中的allocateDirect() 的时候会用到，很多JavaNIO(像netty)的框架中被封装为其他的方法，出现该问题时会抛出Java.lang.OutOfMemoryError: Direct buffer memory异常。

15.有具体的内存泄漏和内存溢出的例子么请举例及解决方案?

1、静态属性导致内存泄露

大量使用static静态变量会导致内存泄露。在Java中，静态属性的生命周期通常伴随着应用整个生命周期（除非ClassLoader符合垃圾回收的条件）。下面来看一个具体的会导致内存泄露的实例：

那么如何优化呢？

1. 第一，进来减少静态变量；
2. 第二，如果使用单例，尽量采用懒加载。

2、 未关闭的资源

无论什么时候当我们创建一个连接或打开一个流，JVM都会分配内存给这些资源。比如，数据库链接、输入流和session对象。忘记关闭这些资源，会阻塞内存，从而导致GC无法进行清理。特别是当程序发生异常时，没有在finally中进行资源关闭的情况。这些未正常关闭的连接，如不进行处理，轻则影响程序性能，重则导致OutOfMemoryError异常发生。

如果进行处理呢？

1. 第一，始终记得在finally中进行资源的关闭；
2. 第二，关闭连接的自身代码不能发生异常；
3. 第三，Java7以上版本可使用try-with-resources代码方式进行资源关闭。

3、 使用ThreadLocal

ThreadLocal提供了线程本地变量，它可以保证访问到的变量属于当前线程，个线程都保存有一个变量副本，每个线程的变量都不同。ThreadLocal相当于提供了一种线程隔离，将变量与线程相绑定，从而实现线程安全的特性。

ThreadLocal的实现中，每个Thread维护一个ThreadLocalMap映射表，key是ThreadLocal实例本身，value是真正需要存储的Object。

ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用来引用它，那么系统GC时，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value。

如果当前线程迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap-> Entry -> value永远无法回收，造成内存泄漏。

如何解决此问题？

• 第一，使用ThreadLocal提供的remove方法，可对当前线程中的value值进行移除；
• 第二，不要使用ThreadLocal.set(null) 的方式清除value，它实际上并没有清除值，而是查找与当前线程线程和null。
• 第三，最好将ThreadLocal视为需要在finally块中关闭的资源，以确保即使在发生异常的情况下也始终关闭该资源。