JVM

Posted 2022-02-05 java_wxid

—

文章目录

• • HotspotJVM后台运行的系统线程
  • JVM内存区域
  • • 程序计数器(线程私有)
    • 虚拟机栈(线程私有)
    • 本地方法区(线程私有)
    • 堆（Heap-线程共享）-运行时数据区
    • • 新生代
      • • Eden区
        • ServivorFrom区
        • ServivorTo区
        • MinorGC 的过程（复制->清空->互换）
      • 老年代
      • 永久代
    • 方法区/永久代（线程共享）
  • 垃圾回收与算法
  • • 如何确定垃圾
    • • 引用计数法
      • 可达性分析
    • 算法
    • • 标记清除算法（Mark-Sweep）
      • 复制算法（copying）
      • 标记整理算法(Mark-Compact)
      • 分代收集算法
      • 新生代与复制算法
      • 老年代与标记复制算法
  • GC 分代收集算法 VS 分区收集算法
  • • 分代收集算法
    • • 在新生代-复制算法
      • 在老年代-标记整理算法
    • 分区收集算法
  • GC 垃圾收集器
  • • Serial 垃圾收集器（单线程、复制算法）
    • ParNew 垃圾收集器（Serial+多线程）
    • Parallel Scavenge 收集器（多线程复制算法、高效）
    • Serial Old 收集器（单线程标记整理算法 ）
    • Parallel Old 收集器（多线程标记整理算法）
    • CMS 收集器（多线程标记清除算法）
    • • 初始标记
      • 并发标记
      • 重新标记
      • 并发清除
    • G1 收集器
  • JMM
  • • JMM(java内存模型)是什么？
    • JMM的三大特性？
    • JMM同步的规定有那些？
    • 什么是主内存？什么是自己的工作内存？
    • JMM内存模型的可见性如何理解？
  • CAS，ABA，volatile
  • • JUC是什么？
    • 什么是并发？什么是并行？
    • volatile是什么？
    • volatile的三大特性?
    • CAS
    • ABA 问题
    • volatile变量的特性
  • JAVA 四中引用类型
  • • 强引用
    • 软引用
    • 弱引用
    • 虚引用
  • JVM参数调优
  • • 调优原则
    • 查看参数
    • 常用参数
    • 实战

HotspotJVM后台运行的系统线程

JVM 允许一个应用并发执行多个线程。

Hotspot JVM 中的 Java线程与原生操作系统线程有直接的映射关系。当线程本地存储、缓冲区分配、同步对象、栈、程序计数器等准备好以后，就会创建一个操作系统原生线程。

当线程本地存储、缓冲区分配、同步对象、栈、程序计数器等准备好以后，就会创建一个操作系统原生线程。Java 线程结束，原生线程随之被回收。操作系统负责调度所有线程，并把它们分配到任何可用的 CPU 上。当原生线程初始化完毕，就会调用 Java 线程的 run() 方法。当线程结束时，会释放原生线程和 Java 线程的所有资源。

Hotspot JVM 后台运行的系统线程主要有下面几个：

• 虚拟机线程：这个线程等待 JVM 到达安全点操作出现。这些操作必须要在独立的线程里执行，因为当堆修改无法进行时，线程都需要 JVM位于安全点。这些操作的类型有：stop-the-world 垃圾回收、线程栈 dump、线程暂停、线程偏向锁解除。
• 周期性任务线程：这线程负责定时器事件（也就是中断），用来调度周期性操作的执行。
• GC 线程：这些线程支持 JVM中不同的垃圾回收活动。
• 编译器线程：这些线程在运行时将字节码动态编译成本地平台相关的机器码。
• 信号分发线程：这个线程接收发送到 JVM的信号并调用适当的 JVM 方法处理。
  

JVM内存区域

JVM 内存区域主要分为线程私有区域【程序计数器、虚拟机栈、本地方法区】、线程共享区域【JAVA 堆、方法区】、直接内存。

• 线程私有数据区域生命周期与线程相同, 依赖用户线程的启动/结束 而 创建/销毁.

在 Hotspot JVM 内, 每个线程都与操作系统的本地线程直接映射, 因此这部分内存区域的存/否跟随本地线程的生/死对应。

• 线程共享区域随虚拟机的启动/关闭而创建/销毁。
• 直接内存并不是 JVM 运行时数据区的一部分, 但也会被频繁的使用

在 JDK 1.4 引入的 NIO 提 供了基于 Channel 与Buffer 的 IO 方式, 它可以使用 Native函数库直接分配堆外内存, 然后使用 DirectByteBuffer对象作为这块内存的引用进行操作(详见: Java I/O 扩展)，这样就避免了在 Java 堆和 Native 堆中来回复制数据，因此在一些场景中可以显著提高性能。

程序计数器(线程私有)

一块较小的内存空间, 是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。正在执行java 方法的话，计数器记录的是虚拟机字节码指令的地址（当前指令的地址）。如果还是 Native方法，则为空。这个内存区域是唯一一个在虚拟机中没有规定任何OutOfMemoryError 情况的区域。

虚拟机栈(线程私有)

java方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧（StackFrame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。栈帧（ Frame）是用来存储数据和部分过程结果的数据结构，同时也被用来处理动态链接(Dynamic Linking)、 方法返回值和异常分派（Dispatch Exception）。栈帧随着方法调用而创建，随着方法结束而销毁——无论方法是正常完成还是异常完成（抛出了在方法内未被捕获的异常）都算作方法结束。

本地方法区(线程私有)

本地方法区和虚拟机栈作用类似，区别是虚拟机栈为执行 Java 方法服务， 而本地方法栈则为 Native 方法服务。

堆（Heap-线程共享）-运行时数据区

线程共享的一块内存区域，创建的对象和数组都保存在 Java 堆内存中，也是垃圾收集器进行垃圾收集的最重要的内存区域。由于现代JVM采用分代收集算法, 因此 Java 堆从 GC 的角度还可以细分为: 新生代(Eden 区、From Survivor 区和 To Survivor 区)和老年代。

新生代

用来存放新生的对象。一般占据堆的 1/3 空间。由于频繁创建对象，所以新生代会频繁触发MinorGC 进行垃圾回收。新生代又分为 Eden 区、ServivorFrom、ServivorTo 三个区。

Eden区

Java 新对象的出生地（如果新创建的对象占用内存很大，则直接分配到老年代）。当 Eden 区内存不够的时候就会触发 MinorGC，对新生代区进行一次垃圾回收。

ServivorFrom区

上一次 GC 的存活者，作为这一次 GC 的被扫描者。

ServivorTo区

保留了一次 MinorGC 过程中的幸存者。

MinorGC 的过程（复制->清空->互换）

MinorGC 采用复制算法。

• 把 Eden 和 ServivorFrom 区域中存活的对象复制到 ServicorTo 区域（如果有对象的年
  龄以及达到了老年的标准，则赋值到老年代区），同时把这些对象的年龄+1（如果ServicorTo不 够位置了就放到老年区）。
• 清空Eden区和ServicorFrom区中的对象。
• ServicorTo区和ServicorFrom区互换，原 ServicorTo成为下一次 GC 时的 ServicorFrom 区。
• 如果有存活的对象在ServicorTo区和ServicorFrom区互换达到15次，进入老年区。

老年代

主要存放应用程序中生命周期长的内存对象。

老年代的对象比较稳定，所以 MajorGC 不会频繁执行。在进行 MajorGC 前一般都先进行了一次MinorGC，使得有新生代的对象晋身入老年代，导致空间不够用时才触发。当无法找到足 够大的连续空间分配给新创建的较大对象时也会提前触发一次 MajorGC 进行垃圾回收腾出空间。  MajorGC 采用标记清除算法：首先扫描一次所有老年代，标记出存活的对象，然后回收没有标记的对象。MajorGC 的耗时比较长，因为要扫描再回收。MajorGC 会产生内存碎片，为了减少内存损耗，我们一般需要进行合并或者标记出来方便下次直接分配。当老年代也满了装不下的时候，就会抛出 OOM（Out of Memory）异常。

永久代

内存的永久保存区域，主要存放 Class 和 Meta（元数据）的信息。

Class在被加载的时候被放入永久区域，它和存放实例的区域不同，GC不会在主程序运行期对永久区域进行清理。所以这也导致了永久代的区域会随着加载的 Class 的增多而胀满，最终抛出 OOM 异常。

在 Java8 中，永久代已经被移除，被一个称为“元数据区”（元空间）的区域所取代。元空间的本质和永久代类似，元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制。类的元数据放入本机内存，字符串池和类的静态变量放入 java 堆中，这样可以加载类的元数据就不再由MaxPermSize 控制， 而由系统的实际可用空间来控制。

方法区/永久代（线程共享）

永久代(Permanent Generation)， 用于存储被 JVM 加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

使用Java堆的永久代来实现方法区， 这样 HotSpot 的垃圾收集器就可以像管理Java堆一样管理这部分内存，而不必为方法区开发专门的内存管理器(永久带的内存回收的主要目标是针对常量池的回收和类型的卸载， 因此收益一般很小)。

运行时常量池（Runtime Constant Pool）是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。
​

垃圾回收与算法

如何确定垃圾

引用计数法

在Java中，引用和对象是有关联的。如果要操作对象则必须用引用进行。因此，很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收。简单说，即一个对象如果没有任何与之关联的引用，即他们的引用计数都不为0，则说明对象不太可能再被用到，那么这个对象就是可回收对象。

可达性分析

为了解决引用计数法的循环引用问题，Java使用了可达性分析的方法。通过一系列的“GC roots”对象作为起点搜索。如果在“GCroots”和一个对象之间没有可达路径，则称该对象是不可达的。要注意的是，不可达对象不等价于可回收对象，不可达对象变为可回收对象至少要经过两次标记过程。两次标记后仍然是可回收对象，则将面临回收。

算法

标记清除算法（Mark-Sweep）

最基础的垃圾回收算法，分为两个阶段，标注和清除。标记阶段标记出所有需要回收的对象，清除阶段回收被标记的对象所占用的空间。

算法最大的问题是内存碎片化严重，后续可能发生大对象不能找到可利用空间的问题。

复制算法（copying）

为了解决 Mark-Sweep 算法内存碎片化的缺陷而被提出的算法。按内存容量将内存划分为等大小的两块。每次只使用其中一块，当这一块内存满后将尚存活的对象复制到另一块上去，把已使用的内存清掉。

算法内存效率高，不易产生碎片，但是最大的问题是可用内存被压缩到了原本的一半。且存活对象增多的话，Copying 算法的效率会大大降低。

标记整理算法(Mark-Compact)

标记阶段和 Mark-Sweep 算法相同，标记后不是清理对象，而是将存活对象移向内存的一端。然后清除端边界外的对象。

分代收集算法

分代收集法是目前大部分 JVM 所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域，一般情况下将 GC 堆划分为老生代(Tenured/Old Generation)和新生代(Young Generation)。老生代的特点是每次垃圾回收时只有少量对象需要被回收，新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因此可以根据不同区域选择不同的算法。

新生代与复制算法

目前大部分 JVM 的 GC 对于新生代都采取 Copying 算法，因为新生代中每次垃圾回收都要回收大部分对象，即要复制的操作比较少，但通常并不是按照 1：1 来划分新生代。一般将新生代划分为一块较大的 Eden 空间和两个较小的 Survivor 空间(From Space, To Space)，每次使用Eden 空间和其中的一块 Survivor 空间，当进行回收时，将该两块空间中还存活的对象复制到另一块 Survivor 空间中。

老年代与标记复制算法

老年代因为每次只回收少量对象，因而采用 Mark-Compact 算法。

1. JAVA 虚拟机提到过的处于方法区的永生代(Permanet Generation)，它用来存储 class 类，常量，方法描述等。对永生代的回收主要包括废弃常量和无用的类。
2. 对象的内存分配主要在新生代的 Eden Space 和 Survivor Space 的 From Space(Survivor 目前存放对象的那一块)，少数情况会直接分配到老生代。
3. 当新生代的 Eden Space 和 From Space 空间不足时就会发生一次 GC，进行 GC 后，Eden Space 和 From Space 区的存活对象会被挪到 To Space，然后将 Eden Space 和 From Space 进行清理。
4. 如果 To Space 无法足够存储某个对象，则将这个对象存储到老生代。
5. 在进行 GC 后，使用的便是 Eden Space 和 To Space 了，如此反复循环。
6. 当对象在 Survivor 区躲过一次 GC 后，其年龄就会+1。默认情况下年龄到达 15 的对象会被移到老生代中。

GC 分代收集算法 VS 分区收集算法

分代收集算法

当前主流 VM 垃圾收集都采用”分代收集”(Generational Collection)算法, 这种算法会根据对象存活周期的不同将内存划分为几块, 如 JVM 中的 新生代、老年代、永久代，这样就可以根据各年代特点分别采用最适当的 GC 算法、

在新生代-复制算法

每次垃圾收集都能发现大批对象已死, 只有少量存活. 因此选用复制算法, 只需要付出少量存活对象的复制成本就可以完成收集.

在老年代-标记整理算法

因为对象存活率高、没有额外空间对它进行分配担保, 就必须采用“标记—清理”或“标记—整理”算法来进行回收, 不必进行内存复制, 且直接腾出空闲内存.

分区收集算法

分区算法则将整个堆空间划分为连续的不同小区间, 每个小区间独立使用, 独立回收. 这样做的好处是可以控制一次回收多少个小区间 , 根据目标停顿时间, 每次合理地回收若干个小区间(而不是整个堆), 从而减少一次 GC 所产生的停顿。
​

GC 垃圾收集器

Java 堆内存被划分为新生代和年老代两部分，新生代主要使用复制和标记-清除垃圾回收算法；年老代主要使用标记-整理垃圾回收算法，因此 java 虚拟中针对新生代和年老代分别提供了多种不同的垃圾收集器。

Serial 垃圾收集器（单线程、复制算法）

Serial（英文连续）是最基本垃圾收集器，使用复制算法，曾经是JDK1.3.1 之前新生代唯一的垃圾收集器。Serial 是一个单线程的收集器，它不但只会使用一个 CPU 或一条线程去完成垃圾收集工作，并且在进行垃圾收集的同时，必须暂停其他所有的工作线程，直到垃圾收集结束。Serial 垃圾收集器虽然在收集垃圾过程中需要暂停所有其他的工作线程，但是它简单高效，对于限定单个 CPU 环境来说，没有线程交互的开销，可以获得最高的单线程垃圾收集效率，因此 Serial垃圾收集器依然是 java 虚拟机运行在 Client 模式下默认的新生代垃圾收集器。

ParNew 垃圾收集器（Serial+多线程）

ParNew 垃圾收集器其实是 Serial 收集器的多线程版本，也使用复制算法，除了使用多线程进行垃圾收集之外，其余的行为和 Serial 收集器完全一样，ParNew 垃圾收集器在垃圾收集过程中同样也要暂停所有其他的工作线程。ParNew 收集器默认开启和 CPU 数目相同的线程数，可以通过-XX:ParallelGCThreads 参数来限制垃圾收集器的线程数。【Parallel：平行的】ParNew虽然是除了多线程外和Serial 收集器几乎完全一样，但是ParNew垃圾收集器是很多 java虚拟机运行在 Server 模式下新生代的默认垃圾收集器。

Parallel Scavenge 收集器（多线程复制算法、高效）

Parallel Scavenge 收集器也是一个新生代垃圾收集器，同样使用复制算法，也是一个多线程的垃圾收集器，它重点关注的是程序达到一个可控制的吞吐量（Thoughput，CPU 用于运行用户代码的时间/CPU 总消耗时间，即吞吐量=运行用户代码时间/(运行用户代码时间+垃圾收集时间)），高吞吐量可以最高效率地利用 CPU 时间，尽快地完成程序的运算任务，主要适用于在后台运算而不需要太多交互的任务。自适应调节策略也是 ParallelScavenge 收集器与 ParNew 收集器的一个重要区别。

Serial Old 收集器（单线程标记整理算法 ）

Serial Old 是 Serial 垃圾收集器年老代版本，它同样是个单线程的收集器，使用标记-整理算法，这个收集器也主要是运行在 Client 默认的 java 虚拟机默认的年老代垃圾收集器。 在 Server 模式下，主要有两个用途：

1. 在 JDK1.5 之前版本中与新生代的 Parallel Scavenge 收集器搭配使用。
2. 作为年老代中使用 CMS 收集器的后备垃圾收集方案。
   新生代 Serial 与年老代 Serial Old 搭配垃圾收集过程图：

新生代 Parallel Scavenge 收集器与 ParNew 收集器工作原理类似，都是多线程的收集器，都使用的是复制算法，在垃圾收集过程中都需要暂停所有的工作线程。
新生代 Parallel Scavenge/ParNew 与年老代 Serial Old 搭配垃圾收集过程图：

Parallel Old 收集器（多线程标记整理算法）

Parallel Old 收集器是Parallel Scavenge的年老代版本，使用多线程的标记-整理算法，在 JDK1.6才开始提供。在 JDK1.6 之前，新生代使用 ParallelScavenge 收集器只能搭配年老代的 Serial Old 收集器，只能保证新生代的吞吐量优先，无法保证整体的吞吐量，Parallel Old 正是为了在年老代同样提供吞吐量优先的垃圾收集器，如果系统对吞吐量要求比较高，可以优先考虑新生代 Parallel Scavenge和年老代 Parallel Old 收集器的搭配策略。
新生代 Parallel Scavenge 和年老代 Parallel Old 收集器搭配运行过程图：

CMS 收集器（多线程标记清除算法）

Concurrent mark sweep(CMS)收集器是一种年老代垃圾收集器，其最主要目标是获取最短垃圾回收停顿时间，和其他年老代使用标记-整理算法不同，它使用多线程的标记-清除算法。最短的垃圾收集停顿时间可以为交互比较高的程序提高用户体验。CMS 工作机制相比其他的垃圾收集器来说更复杂，整个过程分为以下 4 个阶段：

初始标记

只是标记一下 GC Roots 能直接关联的对象，速度很快，仍然需要暂停所有的工作线程。

并发标记

进行 GC Roots 跟踪的过程，和用户线程一起工作，不需要暂停工作线程。

重新标记

为了修正在并发标记期间，因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，仍然需要暂停所有的工作线程。

并发清除

清除 GC Roots 不可达对象，和用户线程一起工作，不需要暂停工作线程。由于耗时最长的并发标记和并发清除过程中，垃圾收集线程可以和用户现在一起并发工作，所以总体上来看CMS 收集器的内存回收和用户线程是一起并发地执行。
CMS 收集器工作过程：

G1 收集器

Garbage first 垃圾收集器是目前垃圾收集器理论发展的最前沿成果，相比与 CMS 收集器，G1 收集器两个最突出的改进是：

1. 基于标记-整理算法，不产生内存碎片。
2. 可以非常精确控制停顿时间，在不牺牲吞吐量前提下，实现低停顿垃圾回收。G1 收集器避免全区域垃圾收集，它把堆内存划分为大小固定的几个独立区域，并且跟踪这些区域的垃圾收集进度，同时在后台维护一个优先级列表，每次根据所允许的收集时间，优先回收垃圾最多的区域。区域划分和优先级区域回收机制，确保 G1 收集器可以在有限时间获得最高的垃圾收集效率。
   

JMM

JMM(java内存模型)是什么？

是一组规则，规范，是一个虚的概念，不真实存在。它定义了程序中的变量访问方式。

JMM的三大特性？

可见性
原子性
有序性

JMM同步的规定有那些？

线程解锁前，必须把共享变量的值刷新回主内存
线程加锁钱，必须读取主内存的最新值到自己的工作内存
加锁解锁是同一把锁

什么是主内存？什么是自己的工作内存？

主内存：就是你买电脑选择8G内存，这个就是你的主内存，也是你new 一个对象存放的地方，是共享内存区域，所有线程都可以访问，java内存模型中规定所有不了存储在主内存里。

工作内存：是JVM在每个线程创建的时候为线程创建一个工作内存，工作内存是每个线程的私有数据区域。
线程对变量的操作是在工作内存中还是主内存中进行的？

JVM运行的实体是线程，线程对变量的读取赋值要先将变量从主内存拷贝自己的工作内存空间，在工作内存中进行操作，操作完成后再将变量写回主内存，不能直接操作主内存的变量，而工作内存中存储的是主内存中的变量副本，所以不同线程之间无法访问对方的工作内存，要通过主内存来完成。

JMM内存模型的可见性如何理解？

现在我要对student对象中age年龄进行赋值，有三个线程t1,t2,t3同时对age进行赋值，这三个线程会从主内存中拷贝一份副本，到自己的工作空间。

t1最先进行赋值，将age改为37，并写回主内存

这个时候其他现在还不知道主内存的值改变了，需要及时通知，这个及时通知就是JMM内存模型的可见性。接着t2和t3知道我手上这个值已经不是最新的值了，需要重新去主内存拷贝最新值，简单来说就是只要主内存的值改变了就通知线程让它重新拷贝。或者可以打个比方：只要我在微信群了@所有人，发红包，指令是“我是最帅的”，群里的其他人都知道我发红包了，让他们全部人回复“我是最帅的”就可以领取红包。
​

CAS，ABA，volatile

JUC是什么？

是java.util.concurrent并发包

什么是并发？什么是并行？

并发：多个线程访问同一个资源。像秒杀一样。
并行：就是你泡方便面，你一边烧热水，一边拆调料包。各种事情同时进行。

volatile是什么？

是java虚拟机提供的轻量级同步机制

volatile的三大特性?

保证可见性（遵守JMM的可见性）
不保证原子性
禁止指令重排

CAS

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

ABA 问题

CAS算法实现一个重要前提需要取出内存中的某时刻的数据并在当下时刻比较并交换，那么在这个时间差类会导致数据的变化。比如，一个线程one从内存位置V中取出A，这个时候另外一个线程two也从内存中取出A，并且线程two进行了一些操作，将值变成了B，然后线程two又将V位置的数据变成A，这个时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。打个比方：你老婆出轨之后又回来，还是原来的老婆嘛？

volatile变量的特性

可见性：线程1从主内存中拿数据1到自己的线程工作空间进行操作（假设是加1）这个时候数据1已经改为数据2了，将数据2写回主内存时通知其他线程（线程2，线程3），主内存中的数据1已改为数据2了，让其他线程重新拿新的数据（数据2）。

不保证原子性：线程1从主内存中拿了一个值为1的数据到自己的工作空间里面进行加1的操作，值变为2，写回主内存，然后还没有来得及通知其他线程，线程1就被线程2抢占了，CPU分配，线程1被挂起，线程2还是拿着原来主内存中的数据值为1进行加1，值变成2，写回主内存，将主内存值为2的替换成2，这时线程1的通知到了，线程2重新去主内存拿值为2的数据。

禁止指令重排：首先指令重排是程序执行的时候不总是从上往下执行的，就像高考答题，可以先做容易的题目再做难的，这时做题的顺序就不是从上往下了。禁止指令重排就杜绝了这种情况。
​

JAVA 四中引用类型

强引用

在 Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到 JVM 也不会回收。因此强引用是造成 Java 内存泄漏的主要原因之一。

软引用

软引用需要用 SoftReference 类来实现，对于只有软引用的对象来说，当系统内存足够时它不会被回收，当系统内存空间不足时它会被回收。软引用通常用在对内存敏感的程序中。

弱引用

弱引用需要用 WeakReference 类来实现，它比软引用的生存期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够，总会回收该对象占用的内存。

虚引用

虚引用需要 PhantomReference 类来实现，它不能单独使用，必须和引用队列联合使用。虚引用的主要作用是跟踪对象被垃圾回收的状态。
​

JVM参数调优

调优原则

• GC的时间足够的小
• GC的次数足够的少
• 发生Full GC的周期足够的长
• 针对JVM堆的设置，一般可以通过-Xms -Xmx限定其最小、最大值，为了防止垃圾收集器在最小、最大之间收缩堆而产生额外的时间，我们通常把最大、最小设置为相同的值。
• 年轻代和年老代将根据默认的比例（1：2）分配堆内存，可以通过调整二者之间的比率NewRadio来调整二者之间的大小，也可以针对回收代，比如年轻代，通过 -XX:newSize -XX:MaxNewSize来设置其绝对大小。同样，为了防止年轻代的堆收缩，我们通常会把-XX:newSize -XX:MaxNewSize设置为同样大小。
• 年轻代和年老代设置多大才算合理？ 如果应用存在大量的临时对象，应该选择更大的年轻代；如果存在相对较多的持久对象，年老代应该适当增大。Full GC尽量少，让年老代尽量缓存常用对象，JVM的默认比例1：2也是这个道理。通过观察应用一段时间，看其他在峰值时年老代会占多少内存，在不影响Full GC的前提下，根据实际情况加大年轻代，比如可以把比例控制在1：1。但应该给年老代至少预留1/3的增长空间。

查看参数

jps -l 查看进程编号
jinfo -flag 具体参数 java进程编号
jinfo -flags 具体参数
查看JVM出厂默认设置：java -XX:+PrintFlagsInitial
查看JVM修改更新的内容：java -XX:+PrintFlagsFinal -version
查看默认垃圾回收器：java -XX:+PrintCommandLineFlags -version

常用参数

-Xmx(-XX:MaxHeapSize)：初始大小内存：初始化的值是物理内存的四分之一
-Xms(-XX:InitialHeapSize)：最大分配内存：初始化的值是物理内存的六十四分之一
-Xss(-XX:ThreadStackSize)：设置单个线程栈的大小，一般默认为512k~1024k
-Xmn：设置年轻代的大小
-XX:MetaspaceSize：设置元空间大小 元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间的区别在于：元空间不在虚拟机中，而是在本地内存中，默认情况下，元空间的大小仅受本地内存限制。

实战

-Xms 128m -Xmx4096m -Xss1024k -XX:MetaspaceSize=512m -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseSerialGC
解析：

• -Xms 128m：初始内存128M
• -Xmx4096m ：最大堆内存4G
• -Xss1024k：初始栈大小1024K
• -XX:MetaspaceSize=512m：元空间512M
• -XX:+PrintCommandLineFlags：打印默认参数
• -XX:+PrintGCDetails ：打印GC回收的细节
• -XX:+UseSerialGC：串行垃圾回收器
• -XX:+PrintGCDetails命令打印的
• -XX:SurvivorRatio：设置新生代中eden和S0/S1空间的比例。
• -XX:NewRatio：配置年轻代与老年代在堆结构的占比。
• -XX:MaxTenuringThreshold：设置垃圾的最大年龄，java8之后这个值最大只能设置为15，最低是0

默认新生区比例：-XX:SurvivorRatio=8,Eden:S0:S1=8:1:1；

• 假如：-XX:SurvivorRatio=4,Eden:S0:S1=4:1:1。SurvivorRatio的值就是设置eden去的比例占多少,S0和S1相同。
• 假如：-XX:NewRatio=2新生代占1，老年代2，年轻代占整个堆的1/3。
• 假如：-XX:NewRatio=4新生代占1，老年代占4，年轻带占整个堆的1/5。NewRatio的值就是设置老年代的占比，剩下的1给新生代。

---