【学习笔记】jvm

舟生tt

已于 2022-05-02 20:48:12 修改

阅读量555

点赞数

文章标签： java

于 2022-04-18 23:03:57 首次发布

本文链接：https://blog.csdn.net/weixin_47585404/article/details/124261682

版权

jvm

视频教程网址黑马程序员JVM完整教程，全网超高评价，全程干货不拖沓_哔哩哔哩_bilibili

文章目录

一，jvm的概念

jvm：Java virtual machine即Java虚拟机，Java程序的运行环境（Java二进制字节码的运行环境），正是因为是虚拟机运行的，所以可以跨平台运行

Java源代码---Javac--->Java class字节码----jvm---->载入内存的运行阶段

二，jvm的内存结构

image-20211209101438818 在这里插入图片描述

1，程序计数器

1.1作用：记录下一条jvm指令的地址

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VD7DfpPc-1650292825916)(D:\文档\学习资料\笔记\jvm.assets\image-20211209101759047.png)]$

1.2特点：

线程私有：随着线程创建而创建，销毁而销毁
不会出现内存溢出
是一块比较小的内存区域

2，虚拟机栈

2.1概念：

线程运行所需要的内存空间
有多个栈帧组成（栈帧：每个方法运行时所需要的内存，包括属性，方法等）
每个线程只能有一个活动栈帧
栈溢出：
- 栈帧太多
- 栈帧太大
- 使用-Xss 空间大小即可改变初始空间大小（初始化是几百k）
注意：
1. 栈不需要垃圾回收机制，因为栈中存放的时运行时方法所需要保存的数据，当方法运行完自然会把原先的数据弹出
2. 栈的空间大小并不是越大越好，由于物理内存是一定的，所以栈的空间设置大了那所能产生的线程反而会变少，但是栈的空间较大是可以增加递归调用的次数的
3. 栈空间方法内线程私有，每个线程对应一个栈空间，不会相互干扰（除了全局变量或其他能够让多个线程访问的变量）

2.2线程诊断（linux命令）

top 查看进程占用情况

ps H -eo pid,tid,%cpu | grep 进程id 显示特点进程的线程总数量（H），进程id，线程id，cpu占比

jstack 进程id 查看Java虚拟机中所有指定的进程信息，再将进程id转换为十六进制对比nid找到对应线程（方法），即可进一步得知出问题的代码行数，在最后还会有关于进程是否发生死锁的信息，同样可以定位到具体的代码行数

3，本地方法栈

概念：jvm连接执行引擎时所需要的方法存放的位置

4，堆

4.1定义

通过new生成的对象都会放在堆中

4.2特点

它是线程共享的，堆中的对象需要考虑线程安全的问题
有垃圾回收机制
内存溢出
- 使用-Xmx 空间大小即可改变初始堆空间的大小（默认是好几个G）

4.3堆内存诊断

工具（Terminal中输入命令）：
1. jps工具：jps 查看当前系统中有哪些Java进程
2. jmap工具：
  
  jmap -heap 进程id 查看特定进程某一时刻堆内存占用情况
  
  jmap -dump:format=b,live,file=文件名.bin 进程id 将某时刻堆的占用情况存为（当前目录下）文件格式为二进制，存活的对象
3. jconsole工具：图形界面的多功能检测工具，可以连续检测
4. jvirsualvm工具：双击（连接）对应进程—>检测---->堆dump—>检查—>查找，即可查看各个实例内存的占用大小

在这里插入图片描述

5，方法区

5.1概念

是所有线程共享的区域，它存贮了类的属性，方法，代码，逻辑上是堆的一部分（但并不强制位置）

5.2组成

在这里插入图片描述

5.3内存溢出

1.8 以前会导致永久代内存溢出（使用的是Java内存）

默认没有内存大小上限，使用 -XX:MaxPermSize=8m设置方法区最大值
1.8 之后会导致元空间内存溢出（使用的是系统内存）

默认没有内存大小上限，使用-XX:MaxMetaspaceSize=8m设置方法区最大值

5.4运行时常量池

//使用javap -c 类名.class 即可将对应类进行进行反编译

常量池（constant pool），就是一张表，虚拟机指令根据这张表找到要执行的类名，方法名，参数类型，字面量等信息
运行时常量池，常量池是class文件中的，当它被加载时，它的常量池信息就会放进运行时常量池，并把里面的符号地址变为真实地址

5.5StringTable（串池）

是个hashTable，贮存k-v值
当执行到需要加载一个字符串时会先到StringTable中查找（边运行边加载，不会一下子将所有字符串都加载进来），如果没有就会将该字符串加入StringTable（可避免重复创建字符串对象）

//反编译中aload代表取出，astore则是存入

在这里插入图片描述

s4是通过String Builder重新生成的，所以和s3不是同一个对象，它也不是存放在串池中的，而是存放在堆区中的

在这里插入图片描述

s5是直接去常量池中找“ab”并不是先找“a”再找“b”最后拼在一起（java编译期间的优化），所以它和s3是一个东西，上一个点的s4是通过s1和s2拼接而来，所以是有可能发生改变的，所以必须用StringBuilder来进行动态拼接

可以使用字符串.intern可以将字符串主动放入串池，并返回池中该字符串的地址，如果池中已经有有了则不会讲字符串放入，并返回池中那个已经有了的字符串地址（jdk1.8以上，若是1.8一下则在存入串池时复制一个新的字符串对象放入串池）
串池位置如组成图所示

5.6StringTable垃圾回收

打印信息
```
-Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
```
设置堆大小，打印StringTable信息，打印垃圾回收信息
哈希表就是数组加链表，数组个数成为桶（buckets）
- 调整 -XX:StringTableSize=桶个数，一定范围内桶的个数越多速度越快
- 考虑将字符串对象是否入池，用intern（）来避免重复创建过多字符串(在下面的例子中如果没有主动加上intern的话是不会进入串池，直接在堆区创建对象)

在这里插入图片描述

6，直接内存

6.1定义：

Direct Memory，常见于 NIO 操作时，用于数据缓冲区

分配回收成本较高，但读写性能高

不受 JVM 内存回收管理，属于系统内存，有可能导致内存溢出

6.2读取原理

不适用直接内存的话，Java在条用系统读写操作时会经过两个缓冲区

byte[] buf = new byte[_1Mb];
int len = file.read(buf);

在这里插入图片描述

使用直接内存可以在系统和堆内存中创建一个共享内存，减少了一层缓冲空间

ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
int len = file.read(bb);

在这里插入图片描述

6.3分配和回收原理

使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法
ByteBuffffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffffer 对象，一旦ByteBuffffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存
使用-XX:+DisableExplicitGC禁用显式垃圾回收（由程序员写代码主动进行的垃圾回收），但是会影响直接内存的主动回收，从而降低性能

三，垃圾回收

1,如何判断对象可以回收

1.1引用计数法

当一个对象没有引用的时候则可以进行垃圾回收

如下图当两个对象相互引用时则不会被回收，从而形成死锁

在这里插入图片描述

1.2 可达性分析算法

Java 虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象
扫描堆中的对象，看是否能够沿着 GC Root对象为起点的引用链找到该对象，找不到，表示可以

回收

哪些对象可以作为 GC Root ?

使用memory analyzer（MAT）来打开使用jmap保存下来的.bin文件即可查看此快照的GC Root，打开主线程即可查看有哪些对象

1.3 四种引用

1.3.1强引用

定义：只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收

1.3.2软引用（SoftReference）

定义：仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象，可以配合引用队列来释放软引用自身
使用软引用

在这里插入图片描述

运行结果

配合队列回收软引用（上面例子中的四个null就没移除了）

1.3.3弱引用（WeakReference）

定义：仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象，可以配合引用队列来释放弱引用自身
使用

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e0qezrfe-1650292635769)(D:\文档\学习资料\笔记\jvm.assets\image-20211211210152824.png)]$

1.3.4虚引用（PhantomReference）

定义：必须配合引用队列使用，主要配合 ByteBuffffer 使用，被引用对象回收时，会将虚引用入队，由 Reference Handler 线程调用虚引用相关方法释放直接内存

1.3.5终结器引用（FinalReference）

定义：同样需要配合引用队列使用，无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由 Finalizer 线程（优先级很低）通过终结器引用找到被引用对象并调用它的 finalize方法，第二次 GC 时才能回收被引用对象

2，垃圾回收算法

2.1标记清除

速度较快，但容易产生空间碎片

2.2标记整理

速度较慢，但不会产生空间碎片（标记+整理空间）

2.3复制

不会有内存碎片，需要占用双倍空间（标记整理+复制）

在这里插入图片描述

（最后还要交换FROM和TO这两个大空间即交换FROM和TO的指针，以备循环）

2.4分代垃圾回收

不会采用其中一种单独的算法，而是多种算法灵活应用
在这里插入图片描述

对象首先分配在伊甸园区域
新生代空间不足时，触发 minor gc，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的对象年龄加 1并且交换 from to
minor gc 会引发 stop the world，暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行
当对象寿命超过阈值时，会晋升至老年代，最大寿命是15（4bit），但如果新生代空间紧张尽管对象还没有到晋升阈值也可以直接放入老年代，或者新进来的对象太大，新生代放不下同样是可以直接放到老年代的
当老年代空间不足，会先尝试触发 minor gc，如果之后空间仍不足，那么触发 full gc，STW（stop the world）的时间更长

含义	参数
堆初始大小	-Xms
堆最大大小	-Xmx 或 -XX:MaxHeapSize=size
新生代大小	-Xmn 或 (-XX:NewSize=size + -XX:MaxNewSize=size )(初始化和最大值同时进行)
幸存区比例（动态）	-XX:InitialSurvivorRatio=ratio（初始化比例）和 -XX:+UseAdaptiveSizePolicy（开关）
幸存区比例	-XX:SurvivorRatio=ratio（如果数值是8则说明新生代有10份空间，8份是伊甸园，将剩下的2份空间进行二等分，一份给from一份给to）
晋升阈值	-XX:MaxTenuringThreshold=threshold
晋升详情	-XX:+PrintTenuringDistribution
GC详情	-XX:+PrintGCDetails -verbose:gc
FullGC 前 MinorGC	-XX:+ScavengeBeforeFullGC（是个开关）

注意：当子线程中发生内存溢出时不会影响主线程的正常运行

四，垃圾回收器

4.1分类

串行单线程
- 堆内存较小，适合个人电脑
吞吐量优先
- 多线程
- 堆内存较大，需要多核 cpu
- 让单位时间内，STW 的时间最短，垃圾回收时间占比最低，这样就称吞吐量高
响应时间优先
- 多线程
- 堆内存较大，需要多核 cpu
- 尽可能让单次 STW 的时间最短

4.2串行

使用

开启命令：-XX:+UseSerialGC = Serial + SerialOld
由两部分组成（两个组成部分分别进行回收）：一个是新生代的回收器Serial 使用复制算法，另一个是老年代的回收器SerialOld使用标记整理算法
回收过程

4.3吞吐量优先

使用
- 开启命令：-XX:+UseParallelGC ~ -XX:+UseParallelOldGC （jdk1.8以上默认开启，两个开启一个就会自动开启另一个）
- 设置并行线程数：-XX:ParallelGCThreads=n
```
//并行与并发的概念
你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。
你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。
你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。
并发的关键是你有处理多个任务的能力，不一定要同时。
并行的关键是你有同时处理多个任务的能力。
所以我认为它们最关键的点就是：是否是『同时』。
```
- 开启动自适应大小策略（包括新生代伊甸园比例，堆大小，晋升阈值）：-XX:+UseAdaptiveSizePolicy
- 设置垃圾回收占用时间：-XX:GCTimeRatio=ratio
  
  GC时间占用率公式为1/（1+ratio），默认为99则GC时间占用率为0.01，vm将调整堆大小来实现一百分钟只能有一分钟用于垃圾回收这个标准，一般是将堆空间增大，占用率才会变小
- 设置每次最大暂停时间：-XX:MaxGCPauseMillis=ms
  
  默认值为200ms，若想要降低每次最大暂停时间，一般是需要减少堆空间的，所以与上一条形成对立关系
同样是由新生代（复制）和老年代组成（标记整理）
回收过程（同时进行的线程数默认与你的cpu核数相同）

4.4响应时间优先（CMS）

使用
- 开启命令：-XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld （老年代和新生代回收器）
  
  老年代回收器在某些时刻可以和用户线程并发执行（concurrent），不过有时会并发失败，并发失败时则退化到 SerialOld 串行回收器
- 设置并行、并发线程数：-XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=threads
  
  并行线程数默认值为cpu核数，并发线程数建议为并行的四分之一
- 设置启动垃圾回收内存占比时机：-XX:CMSInitiatingOccupancyFraction=percent
```
//浮动垃圾：在并发清理过程中产生的垃圾
```
  如果像其他垃圾回收机制一样等到内存占比接近100%时在启动的话，由于浮动垃圾的存在就有可能发生内存溢出，所以需要设置启动垃圾回收内存占比时机
- 开启在重新标记之前对新生代进行一次垃圾回收：-XX:+CMSScavengeBeforeRemark
  
  以减少重新标记时查找的数量（是一个开关，+代表开启，-代表禁用）
同样有新生代（复制算法）和老年代（标记清除算法）回收器组成

由于老年代并没有整理空间碎片的功能，所以会由于空间碎片导致的空间不足导致并发失败，此时则会采用SerialOld 串行回收器执行标记整理算法
回收过程（在并发标记后需要再进行一次标记，因为在并发标记过程中其他线程可能改变对象的引用之类） $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vFixUw2C-1650292635774)(D:\文档\学习资料\笔记\jvm.assets\image-20211212190708440.png)]$

4.5G1

定义：Garbage First

2004 论文发布

2009 JDK 6u14 体验

2012 JDK 7u4 官方支持

2017 JDK 9 默认（废弃CMS）
适用场景

同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是 200 ms

适应超大堆内存，会将堆划分为多个大小相等的 Region（分区，里面同样有伊甸园等结构）

整体上是 标记+整理算法，两个区域之间是 复制算法
相关 JVM 参数

启用（jdk1.8不是默认的）：-XX:+UseG1GC

设置分区的大小（必须是2的整数倍）：-XX:G1HeapRegionSize=size

设置暂停目标：-XX:MaxGCPauseMillis=time

1) G1 垃圾回收阶段

2) Young Collection（新生代的垃圾回收）

会有stw

E代表伊甸园

S表示幸存区，将多个伊甸园复制到一个幸存区

O表示老年代，到达晋升阈值就会放到老年代，年龄不够就和其他伊甸园一样进行垃圾回收并复制到新的幸存区

3) Young Collection + CM

在 Young GC 时会进行 GC Root 的初始标记（标记根对象）
老年代占用堆空间比例达到阈值时，进行并发标记（标记根对象下的子对象，不会 STW），由下面的 JVM 参数决定-XX:InitiatingHeapOccupancyPercent=percent （默认45%）

4) Mixed Collection

会对 E、S、O 进行全面垃圾回收，在老年代进行回收时因为有最大暂停时间的目标，所以会选择回收价值最大的几个老年代进行回收

最终标记（Remark，相当于CMS的重新标记）会 STW
拷贝存活（Evacuation）会 STW

设置最大存活时间：-XX:MaxGCPauseMillis=ms

5) Full GC

SerialGC

新生代内存不足发生的垃圾收集 - minor gc

老年代内存不足发生的垃圾收集 - full gc
ParallelGC

新生代内存不足发生的垃圾收集 - minor gc

老年代内存不足发生的垃圾收集 - full gc
CMS

新生代内存不足发生的垃圾收集 - minor gc

老年代内存不足
G1

新生代内存不足发生的垃圾收集 - minor gc

老年代内存不足

其中CMS和G1的老年代内存不足要分两种情况：
1，并发回收速度可以跟得上垃圾的产生速度，则不算是full GC
2，并发护手速度跟不上垃圾的产生速度，此时会发生并发失败，则将老年代的回收器退化为串回收的老年代回收器，这种则可以称为full GC,与SerialOld不同的是，G1中退化的老年代回收器已经优化为多线程了

6) Young Collection 跨代引用

新生代回收的跨代引用（老年代引用新生代）问题

脏卡：引用了新生代对象的老年区对象

在新生代的可达性分析中需要找到其根对象（跟对象一般在老年区中），如果要遍历整个老年区效率太低，于是将老年去进行分区，成为卡表（每个卡大概时512k），只需要关注脏卡即可

卡表与 Remembered Set（记录外部对自身的引用，将其标记为脏卡）

在引用变更时通过 post-write barrier + dirty card queue

//后写屏障：用于更新脏卡，将更新操作放在脏卡队列中
//脏卡队列：更新脏卡是个异步操作，会有线程来执行队列里的操作

concurrent refinement threads 更新 Remembered Set

7) Remark（最终标记，重新标记）

pre-write barrier（前写屏障） + satb_mark_queue（混合标记队列）

//黑色代表已经标记完成，灰色灰色代表正在进行标记，白色代表尚未标记
//在进行并发标记时如果有其他线程改变对象引用，前写屏障会将引用被改变的对象加入混合标记队列，再由其他线程来检查队列中的对象是否可以被垃圾回收（父级对象是强引用之类），从而进行一个最终标记（重新标记）

8)调优： JDK 8u20 字符串去重

优点：节省大量内存
缺点：略微多占用了 cpu 时间，新生代回收时间略微增加
开启命令：-XX:+UseStringDeduplication
过程：

String s1 = new String("hello"); // char[]{'h','e','l','l','o'} 
String s2 = new String("hello"); // char[]{'h','e','l','l','o'}

将所有新分配的字符串放入一个队列
当新生代回收时，G1并发检查是否有字符串重复
如果它们值一样，让它们引用同一个 char[]

注意

与 String.intern() 不一样，String.intern() 关注的是字符串对象，而字符串去重关注的是 char[]，在 JVM 内部，使用了不同的字符串表

9)功能增强： JDK 8u40 并发标记类卸载

说明：所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类，在大型公司有许多自定义的类加载器，这个功能十分有必要
开启命令：-XX:+ClassUnloadingWithConcurrentMark （默认启用）

10) 功能增强：JDK 8u60 回收巨型对象

//巨型对象：一个对象大于 region（分区） 的一半时，称之为巨型对象

G1 不会对巨型对象进行拷贝
回收时被优先考虑
G1 会跟踪巨型对象在老年代中所有 incoming （引用巨型对象的引用）引用，这样老年代 incoming 引用为0 的巨型对象（即没有老年代引用他了）就可以在新生代垃圾回收时处理掉

11)功能增强： JDK 9 并发标记起始时间的调整

并发标记必须在堆空间占满前完成，否则退化为 FullGC，stw会比较长，尽快启动混合回收就能有效避免退化为FullGC
JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent 来调整启动老年代垃圾回收的内存占比阈值
```
但是这个阈值调太小会频繁进行老年代回收，调太大会触发FullGC，都会降低运行效率
```
JDK 9 可以动态调整

-XX:InitiatingHeapOccupancyPercent 用来设置初始值

进行数据采样并动态调整（相当于是让机器来代替人脑去进行调试，试出最优阈值）

总会添加一个安全的空档空间（多一份保障来容纳浮动垃圾）

12) 更多：JDK 9 更高效的回收

250+增强

180+bug修复

https://docs.oracle.com/en/java/javase/12/gctuning

五，垃圾回收调优

预备知识：

掌握 GC 相关的 VM 参数，会基本的空间调整
- 参考官网：Commands for Working with Directive Files (oracle.com)
- “jdk的bin目录\java” -XX：+PrintFlagsFinal -Version / findstr “GC”
  
  打印在本机上有关于GC的相关设置
掌握相关工具
明白一点：调优跟应用、环境有关，没有放之四海而皆准的法则

5.1 调优领域

内存
锁竞争
cpu 占用
io

5.2 确定目标

【低延迟】还是【高吞吐量】，选择合适的回收器
CMS，G1，ZGC（低延迟）
ParallelGC（高吞吐）
Zing（据说是零延迟，可以处理超大堆空间）

5.3 最快的 GC

答案是不发生 GC
查看 FullGC 前后的内存占用，考虑下面几个问题数据是不是太多？

resultSet = statement.executeQuery(“select * from 大表 limit n”)

不可以直接将数据库还没经过筛选的数据全部放进Java内存中，应当在数据库查询时就尽可能加上筛选条件
数据表示是否太臃肿？
- 对象图：查询出需要的数据即可，不需要将对象整个数据放进来
- 对象大小：能用基本的数据类型就用最基本的，如果用封装类型会增加内存
是否存在内存泄漏？
- 不可以往对象中一直加数据，从而造成泄露/溢出
- 若是长时间存在的对象：考虑用软、弱引用
- 缓存数据：不建议直接用Java实现，可以考虑用第三方缓存（如redis）实现，第三方自己会考虑数据存活时间的

5.4 新生代调优

新生代的特点
- 所有的 new 操作的内存分配非常廉价
  - TLAB thread-local allocation buffffer（线程分配局部缓冲区）
```
//TLAB：每个线程都会在伊甸园中分配一块区域，以解决不同线程在申请/分配空间时的并发安全问题
```
- 死亡对象的回收代价是零
- 大部分对象用过即死
- Minor GC 的时间远远低于 Full GC（相差大概一到两个数量级）

新生代空间越大越好吗？

设置新生代最大、初始化空间命令：-Xmn

设置新生代堆的初始大小和最大大小（字节）。GC在这一地区的出现频率高于其他地区。如果新生代的空间太小，则会执行许多次要的垃圾回收。如果空间太大，很多新生代都可以晋升到老年代，则仅靠FullGC来回收垃圾，这可能需要很长时间才能完成。建议您将年轻一代的大小保持在25%以上，小于总堆大小的50%

新生代需要能容纳所有【并发量 * (一次请求-响应中产生的数据)】的数据
幸存区需要能保留【当前活跃对象+需要晋升对象】
晋升阈值配置得当，让长时间存活对象尽快晋升

-XX:MaxTenuringThreshold=threshold （最大晋升阈值）

-XX:+PrintTenuringDistribution （显示晋升详细信息）

Desired survivor size 48286924 bytes, new threshold 10 (max 10)

- age 1: 28992024 bytes, 28992024 total 
\- age 2: 1366864 bytes, 30358888 total 
\- age 3: 1425912 bytes, 31784800 total 
...

5.5 老年代调优

//以 CMS 为例

CMS 的老年代内存越大越好
先尝试不做调优，如果没有 Full GC 那么已经…，否则先尝试调优新生代
观察发生 Full GC 时老年代内存占用，将老年代内存预设调大 1/4 ~ 1/3

-XX:CMSInitiatingOccupancyFraction=percent（启动FullGC内存占比阈值一般是75%-80%）

5.6 案例

案例1 Full GC 和 Minor GC频繁
1. 增大新生代空间
2. 设置较大的晋升阈值
案例2 请求高峰期发生 Full GC，单次暂停时间特别长（低延迟：CMS）
- 开启在重新标记之前对新生代进行一次垃圾回收：-XX:+CMSScavengeBeforeRemark
  
  减少重新标记所耗费的时间
案例3 老年代充裕情况下，发生 Full GC （CMS jdk1.7）

jdk1.8之前，可能是永久代空间不足，提高或不限制永久代空间即可
```
默认没有内存大小上限，使用 -XX:MaxPermSize=8m设置方法区最大值
```

六，类加载与字节码技术

学习目标：
1. 类文件结构
2. 字节码指令
3. 编译期处理
4. 类加载阶段
5. 类加载器
6. 运行期优化

1. 类文件结构

一个简单的 HelloWorld.java

package cn.itcast.jvm.t5; // HelloWorld 示例 
public class HelloWorld { 
    public static void main(String[] args) {
    	System.out.println("hello world"); 
    }
}

执行 javac -parameters -d . HellowWorld.java

//加上-parameters就会保留args的参数信息

编译为 HelloWorld.class 后是这个样子的：

[root@localhost ~]# od -t xC HelloWorld.class 
0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09 
0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07 
0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e 
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63 
0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01 
0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63 
0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f 
0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16 
0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 
0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13 
0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 
0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61 
0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46 
0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64 
0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e 
0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64 
0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74 
0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 
0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61 
0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61 
0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f 
0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 
0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76 
0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 
0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a 
0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 
0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01 
0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01 
0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00 
0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00 
0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00 
0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00 
0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a 
0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b 
0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00 
0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00 
0001120 00 00 02 00 14

根据 JVM 规范，类文件结构如下：

ClassFile { 
//u4：0-4个字节；魔数magic number
u4 magic; 
//u2：4-6个字节，以此类推；小版本号
u2 minor_version; 
//大版本号
u2 major_version; 
//常量池信息
u2 constant_pool_count; 	//常量池长度
cp_info constant_pool[constant_pool_count-1]; 
//访问修饰（类是公共的还是私有的等等）
u2 access_flags; 
//类名，包名
u2 this_class; 
//父类信息
u2 super_class; 
//接口信息
u2 interfaces_count; 
u2 interfaces[interfaces_count]; 
//成员变量信息
u2 fields_count; 
field_info fields[fields_count]; 
//类中的方法信息
u2 methods_count; 
method_info methods[methods_count]; 
//类中的附加属性信息
u2 attributes_count; 

attribute_info attributes[attributes_count]; 

}