文章目录
为什么要学习JVM
-
面试的需要(BATJ、TMD,PKQ等面试都爱问)
-
中高级程序员必备技能
- 项目管理、调优的需求
-
追求极客的精神
- 比如:垃圾回收算法、JIT(及时编译器)、底层原理
Java内存区域
运行时数据区域
Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。JDK 1.8和之前的版本略有不用,见下图:
方法区的变化
JDK1.8与JDK1.7最大的区别是:JDK1.8将永久代取消,取而代之的是元空间,在JDK1.8中方法区是由元空间来实现,所以原来属于方法区的运行时常量池就属于元空间了。
元空间属于本地内存,所以元空间的大小仅受本地内存限制,但是可以通过-XX:MaxMetaspaceSize进行增长上限的最大值设置,默认值为4G,元空间的初始空间大小可以通过-XX:MetaspaceSize进行设置,默认值为20.8M,还有一些其他参数可以进行设置,元空间大小会自动进行调整。
数据的迁移
在JDK1.7之前运行时常量池,字符串常量池,静态域等存放在方法区, 运行时常量池逻辑包含字符串常量池,此时hotspot虚拟机对方法区的实现为永久代。
在JDK1.7中字符串常量池和静态域被从方法区(永久代)拿到了堆中(在堆中另开辟了一块空间),这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区,也就是hotspot中的永久代。
在JDK1.8 hotspot移除了永久代,用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆,运行时常量池还在方法区,只不过方法区的实现从永久代变成了元空间(Metaspace)。
元空间简介
用于存储已被虚拟机加载的类元数据,符号引用,即包括运行时常量池。元空间的本质和永久代类似,都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于:元空间并不在虚拟机中,而是使用本地内存。因此,默认情况下,元空间的大小仅受本地内存限制,但可以通过以下参数来指定元空间的大小:-XX:MetaspaceSize。
元数据
元数据(Meta Date),关于数据的数据或者叫做用来描述数据的数据或者叫做信息的信息。
这些定义都很是抽象,我们可以把元数据简单的理解成,最小的数据单位。元数据可以为数据说明其元素或属性(名称、大小、数据类型、等),或其结构(长度、字段、数据列),或其相关数据(位于何处、如何联系、拥有者)
为什么移除永久代?
由于永久代使用jvm内存经常不够用或发生内存泄露,引发恼人的OutOfMemoryError异常(在Java Web开发中非常常见)。
移除永久代可以促进HotSpot JVM与JRockit VM两种虚拟机的融合,因为JRockit没有永久代。
对永久代进行调优是很困难的。永久代中的元数据可能会随着每一次Full GC发生而进行移动。
为什么要引入元空间
字符串常量存在永久代中,容易出现性能问题和内存溢出。
类及方法的信息等比较难确定其大小,因此对于永久代的大小指定比较困难,太小容易出现永久代溢出,太大则容易导致老年代溢出。
永久代会为 GC 带来不必要的复杂度,并且回收效率偏低。
Oracle 可能会将HotSpot与Jrockit两种虚拟机合二为一。
线程私有的:程序计数器、虚拟机栈、本地方法栈
线程共享的:堆、方法区、直接内存
程序计数器
程序计数器是一块较小的内存空间,可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完成。
另外,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各线程之间计数器互不影响,独立存储,我们称这类内存区域为“线程私有”的内存。
从上面的介绍中我们知道程序计数器主要有两个作用:
- 字节码解释器通过改变程序计数器来依次读取指令,从而实现代码的流程控制,如:顺序执行、选择、循环、异常处理。
- 在多线程的情况下,程序计数器用于记录当前线程执行的位置,从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
如果线程正在执行的是一个Java方法,这个计数器记录的是正在执行的虚拟机字节码指令的地址;如果正在执行的是本地(Native)方法,这个计数器值则为空。
注意:程序计数器是唯一一个不会出现 OutOfMemoryError 的内存区域,它的生命周期随着线程的创建而创建,随着线程的结束而死亡。
Java 虚拟机栈
与程序计数器一样,Java 虚拟机栈也是线程私有的,它的生命周期和线程相同,描述的是 Java 方法执行的内存模型,每次方法调用的数据都是通过栈传递的。
虚拟机栈描述的是Java方法执行的线程内存模型:每个方法执行的时候,Java虚拟机都会同步创建一个栈帧用于存储局部变量表、操作数栈、动态链接、方法出口信息。每一个方法被调用直至执行完毕的过程,就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
局部变量表主要存放了编译器可知的各种数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(reference 类型,它不同于对象本身,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄或其他与此对象相关的位置)和**returnAddress类型(**指向了一条字节码指令的地址)。
这些数据类型在局部变量表中的存储空间以局部变量槽(Slot)来表示,其中64位长度的long和double类型的数据会占用两个变量槽,其余类型只占用一个。局部变量表所需的内存空间在编译期间完成分配,当进入一个方法时,这个方法需要在栈帧中分配多大的局部变量空间是完全确定的,在方法运行期间不会改变局部变量表的大小。("大小"指的是变量槽的数量)
Java 虚拟机栈会出现两种错误:StackOverFlowError
和 OutOfMemoryError
。
StackOverFlowError
: 若 Java 虚拟机栈的内存大小不允许动态扩展,那么当线程请求栈的深度超过当前 Java 虚拟机栈的最大深度的时候,就抛出 StackOverFlowError 错误。OutOfMemoryError
: 若 Java 虚拟机栈的内存大小允许动态扩展,且当线程请求栈时内存用完了,无法再动态扩展了,此时抛出 OutOfMemoryError 错误。
扩展:那么方法/函数如何调用?
Java 栈可用类比数据结构中栈,Java 栈中保存的主要内容是栈帧,每一次函数调用都会有一个对应的栈帧被压入 Java 栈,每一个函数调用结束后,都会有一个栈帧被弹出。
Java 方法有两种返回方式:
- return 语句。
- 抛出异常。
不管哪种返回方式都会导致栈帧被弹出。
本地方法栈
和虚拟机栈所发挥的作用非常相似,区别是: 虚拟机栈为虚拟机执行 Java 方法 (也就是字节码)服务,而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
方法执行完毕后相应的栈帧也会出栈并释放内存空间,也会出现 StackOverFlowError 和 OutOfMemoryError 两种错误。
堆
Java 堆是Java 虚拟机所管理的内存中最大的一块,也是所有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例,几乎所有的对象实例以及数组都在这里分配内存。
Java 堆是垃圾收集器管理的主要区域,因此也被称作GC 堆(Garbage Collected Heap).从垃圾回收的角度,由于现在收集器基本都采用分代垃圾收集算法,所以 Java 堆还可以细分为:新生代和老年代:再细致一点有:Eden 空间、From Survivor、To Survivor 空间等。进一步划分的目的是更好地回收内存,或者更快地分配内存。
在 JDK 7 版本及JDK 7 版本之前,堆内存被通常被分为下面三部分:
-
新生代内存(Young Generation)
-
老生代(Old Generation)
-
永生代(Permanent Generation)
JDK 8 版本之后方法区(HotSpot 的永久代)被彻底移除了(JDK1.7 就已经开始了),取而代之是元空间,元空间使用的是直接内存。
上图所示的 Eden 区、两个 Survivor 区都属于新生代(为了区分,这两个 Survivor 区域按照顺序被命名为 s1 和 s2),中间一层属于老年代。
大部分情况,对象都会首先在 Eden 区域分配,在一次新生代垃圾回收后,如果对象还存活,则会进入 s1 或者 s2,并且对象的年龄还会加 1(Eden 区->Survivor 区后对象的初始年龄变为 1),当它的年龄增加到一定程度(默认为 15 岁),就会被晋升到老年代中。对象晋升到老年代的年龄阈值,可以通过参数 -XX:MaxTenuringThreshold
来设置。
新生代到老年代的阈值:
Hotspot遍历所有对象时,按照年龄从小到大对其所占用的大小进行累积,当累积的某个年龄大小超过了survivor区的一半时,取这个年龄和MaxTenuringThreshold中更小的一个值,作为新的晋升年龄阈值。
堆这里最容易出现的就是 OutOfMemoryError 错误,并且出现这种错误之后的表现形式还会有几种,比如:
OutOfMemoryError: GC Overhead Limit Exceeded
: 当JVM花太多时间执行垃圾回收并且只能回收很少的堆空间时,就会发生此错误。java.lang.OutOfMemoryError: Java heap space
:假如在创建新的对象时, 堆内存中的空间不足以存放新创建的对象, 就会引发java.lang.OutOfMemoryError: Java heap space
错误。(和本机物理内存无关,和你配置的内存大小有关!)
方法区
方法区与 Java 堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做 Non-Heap(非堆),目的应该是与 Java 堆区分开来。方法区也被称为永久代。
方法区和永久代的关系
《Java 虚拟机规范》只是规定了有方法区这么个概念和它的作用,并没有规定如何去实现它。那么,在不同的 JVM 上方法区的实现肯定是不同的了。方法区和永久代的关系很像 Java 中接口和类的关系,类实现了接口,而永久代就是 HotSpot 虚拟机对虚拟机规范中方法区的一种实现方式。 也就是说,永久代是 HotSpot 的概念,方法区是 Java 虚拟机规范中的定义,是一种规范,而永久代是一种实现,一个是标准一个是实现,其他的虚拟机实现并没有永久代这一说法。
常用参数
JDK 1.8 之前永久代还没被彻底移除的时候通常通过下面这些参数来调节方法区大小
-XX:PermSize=N //方法区 (永久代) 初始大小
-XX:MaxPermSize=N //方法区 (永久代) 最大大小,超过这个值将会抛出 OutOfMemoryError 异常:java.lang.OutOfMemoryError: PermGen
相对而言,垃圾收集行为在这个区域是比较少出现的,但并非数据进入方法区后就“永久存在”了。这区域的内存回收目标主要是针对常量池的回收和对类型的卸载,一般来说这个区域的回收效果比较好。
JDK 1.8 的时候,方法区(HotSpot 的永久代)被彻底移除了(JDK1.7 就已经开始了),取而代之是元空间,元空间使用的是直接内存。
下面是一些常用参数:
-XX:MetaspaceSize=N //设置 Metaspace 的初始(和最小大小)
-XX:MaxMetaspaceSize=N //设置 Metaspace 的最大大小
与永久代很大的不同就是,如果不指定大小的话,随着更多类的创建,虚拟机会耗尽所有可用的系统内存。
元空间
JDK 1.8之后使用元空间(存放在内存里)替代永久代,为什么要这样做?
-
整个永久代有一个 JVM 本身设置固定大小上限,无法进行调整,而元空间使用的是直接内存,受本机可用内存的限制,虽然元空间仍旧可能溢出,但是比原来出现的几率会更小。
当你元空间溢出时会得到如下错误:
java.lang.OutOfMemoryError: MetaSpace
你可以使用
-XX:MaxMetaspaceSize
标志设置最大元空间大小,默认值为 unlimited,这意味着它只受系统内存的限制。-XX:MetaspaceSize
调整标志定义元空间的初始大小如果未指定此标志,则 Metaspace 将根据运行时的应用程序需求动态地重新调整大小。 -
元空间里面存放的是类的元数据,这样加载多少类的元数据就不由
MaxPermSize
控制了, 而由系统的实际可用空间来控制,这样能加载的类就更多了。
运行时常量池
运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外,还有常量池信息(用于存放编译期生成的各种字面量和符号引用)
既然运行时常量池是方法区的一部分,自然受到方法区内存的限制,当常量池无法再申请到内存时会抛出 OutOfMemoryError 错误。
**JDK1.7 及之后版本的 JVM 已经将字符串常量池从方法区中移了出来,在 Java 堆(Heap)中开辟了一块区域存放字符串常量池。**但是运行时常量池的其他内容还在方法区,也就是在元空间里面。
直接内存
直接内存并不是虚拟机运行时数据区的一部分,也不是虚拟机规范中定义的内存区域,但是这部分内存也被频繁地使用。而且也可能导致 OutOfMemoryError 错误出现。
JDK1.4 中新加入的 NIO(New Input/Output) 类,引入了一种基于通道(Channel) 与缓存区(Buffer) 的 I/O 方式,它可以直接使用 Native 函数库直接分配堆外内存,然后通过一个存储在 Java 堆中的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样就能在一些场景中显著提高性能,因为避免了在 Java 堆和 Native 堆之间来回复制数据。
本机直接内存的分配不会受到 Java 堆的限制,但是,既然是内存就会受到本机总内存大小以及处理器寻址空间的限制。
HotSpot虚拟机对象探秘
对象的创建
通过上面的介绍我们大概知道了虚拟机的内存情况,下面我们来详细的了解一下 HotSpot 虚拟机在 Java 堆中对象分配、布局和访问的全过程。
Step1:类加载检查
虚拟机遇到一条 new 指令时,首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用,并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有,那必须先执行相应的类加载过程。
Step2:分配内存
在类加载检查通过后,接下来虚拟机将为新生对象分配内存。对象所需的内存大小在类加载完成后便可确定,为对象分配空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。分配方式有 “指针碰撞” 和 “空闲列表” 两种,选择那种分配方式由 Java 堆是否规整决定,而 Java 堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。
内存分配的两种方式:
选择以上两种方式中的哪一种,取决于 Java 堆内存是否规整。而 Java 堆内存是否规整,取决于 GC 收集器的算法是"标记-清除",还是"标记-整理"(也称作"标记-压缩"),值得注意的是,复制算法内存也是规整的。
内存分配并发问题
在创建对象的时候有一个很重要的问题,就是线程安全,因为在实际开发过程中,创建对象是很频繁的事情,作为虚拟机来说,必须要保证线程是安全的,通常来讲,虚拟机采用两种方式来保证线程安全:
- CAS+失败重试: CAS 是乐观锁的一种实现方式。所谓乐观锁就是,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止。虚拟机采用 CAS 配上失败重试的方式保证更新操作的原子性。
- **本地线程分配缓冲(TLAB):**为每一个线程预先在 Eden 区分配一块儿内存,称为TLAB;JVM 在给线程中的对象分配内存时,首先在 TLAB 分配,当对象大于 TLAB 中的剩余内存或 TLAB 的内存已用尽时,再采用上述的 CAS 进行内存分配。
Step3:初始化零值
内存分配完成后,虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头),这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用,程序能访问到这些字段的数据类型所对应的零值。
Step4:设置对象头
初始化零值完成之后,虚拟机要对 对象进行必要的设置,例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的 GC 分代年龄等信息。 这些信息存放在对象头中。 另外,根据虚拟机当前运行状态的不同,如是否启用偏向锁等,对象头会有不同的设置方式。
Step5:执行 init 方法
在上面工作都完成之后,从虚拟机的视角来看,一个新的对象已经产生了,但从 Java 程序的视角来看,对象创建才刚开始。<init>
方法还没有执行,所有的字段都还为零。所以一般来说,执行 new 指令之后会接着执行<init>
方法,把对象按照程序员的意愿进行初始化,这样一个真正可用的对象才算完全产生出来。(<init>
方法即初始化方法或者称为构造方法)
对象的内存布局
在 Hotspot 虚拟机中,对象在内存中的布局可以分为 3 块区域:对象头、实例数据和对齐填充。
对象头
Hotspot 虚拟机的对象头包括两部分信息,第一部分用于存储对象自身的运行时数据,另一部分是类型指针。
对象自身的运行时数据
包括哈希码、GC 分代年龄、锁状态标志、线程持有的锁、偏向线程ID和偏向时间戳等,这部分数据的长度在32位和64位的虚拟机中分别为32bit和64bit,称为**“Mark Word”**。
对象需要存储的运行时数据很多,其实已经超过64bit,因对象头里的信息是与对象自身定义无关的额外存储成本,所以Mark Word被设计成一个动态数据结构,根据对象的状态复用自己的存储空间。
在32位的HotSpot虚拟机中,Mark Word存储内容如下:
如:在对象未被锁时,Mark Word的25bit存储对象的hashcode,4bit存储分代年龄,1bit表示是否偏向锁,2bit用于存储锁标志位。不用的锁状态用不同的锁标志位表示。
可以看到,分代年龄最大为15,因为只用4bit存储。
类型指针
类型指针是对象指向它的类型元数据的指针,Java虚拟机通过这个指针来确定该对象是哪个类的实例。并不是所有的虚拟机实现都必须在对象数据上保留类型指针,即查找对象的元数据信息不一定要经过对象本身。
如果对象是一个Java数组,那在对象头上还必须有一块用于记录数组长度的数据,因为虚拟机可以通过普通Java对象的元数据信息确定Java对象的大小,但是如果数组的长度是不确定的,将无法通过元数据中的信息推断出数组的大小。
实例数据
实例数据部分是对象真正存储的有效信息,即我们定义的各种类型的字段内容,无论是从父类继承下来的,还是子类中定义的,都必须记录下来。
HotSpot虚拟机默认的分配顺序为longs/doubles、ints、shorts/chars、bytes/booleans、oops,从以上默认的分配策略中可以看到,相同宽度的字段总是被分配到一起存放,在满足这个前提条件下,在父类中定义的变量会出现在子类之前。
对齐填充
对齐填充部分不是必然存在的,也没有什么特别的含义,仅仅起占位作用。 因为 Hotspot 虚拟机的自动内存管理系统要求对象起始地址必须是 8 字节的整数倍,换句话说就是对象的大小必须是 8 字节的整数倍。而对象头部分正好是 8 字节的倍数(1 倍或 2 倍),因此,当对象实例数据部分没有对齐时,就需要通过对齐填充来补全。
对象的访问定位
建立对象就是为了使用对象,我们的 Java 程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式由虚拟机实现而定,目前主流的访问方式有①使用句柄和②直接指针两种:
句柄: 如果使用句柄的话,那么 Java 堆中将会划分出一块内存来作为句柄池,reference 中存储的就是对象的句柄地址,而句柄中包含了对象实例数据与类型数据各自的具体地址信息;
直接指针: 如果使用直接指针访问,那么 Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息,而 reference 中存储的直接就是对象的地址。
这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址,在对象被移动时只会改变句柄中的实例数据指针,而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快,它节省了一次指针定位的时间开销。
String 类和常量池
String对象的两种创建方式:
String str1 = "abcd";//先检查字符串常量池中有没有"abcd",如果字符串常量池中没有,则创建一个,然后 str1 指向字符串常量池中的对象,如果有,则直接将 str1 指向"abcd"";
String str2 = new String("abcd");//堆中创建一个新的对象
String str3 = new String("abcd");//堆中创建一个新的对象
System.out.println(str1==str2);//false
System.out.println(str2==str3);//false
因为str1是字面量,字面量是存储在常量池的,通过new创建的是一个对象,对象是存储在java堆的。
这两种不同的创建方法是有差别的。
- 第一种方式是在常量池中拿对象;
- 第二种方式是直接在堆内存空间创建一个新的对象。
记住一点:只要使用 new 方法,便需要创建新的对象。
String 类型的常量池比较特殊。它的主要使用方法有两种:
- 直接使用双引号声明出来的 String 对象会直接存储在常量池中。
- 如果不是用双引号声明的 String 对象,可以使用 String 提供的 intern 方法。String.intern() 是一个 Native 方法,它的作用是:如果运行时常量池中已经包含一个等于此 String 对象内容的字符串,则返回常量池中该字符串的引用;如果没有,JDK1.7之前(不包含1.7)的处理方式是在常量池中创建与此 String 内容相同的字符串(就是在常量池存储一个副本),并返回常量池中创建的字符串的引用,JDK1.7以及之后的处理方式是在常量池中存储此字符串的引用,并返回该引用。注意:JDK 1.6及以后存储的是字符串的一个副本,JDK 1.7及其以后存储的是字符串的引用,存储内容变了。见几张图轻松理解String.intern()
String s1 = new String("计算机");
String s2 = s1.intern();
String s3 = "计算机";
System.out.println(s2);//计算机
System.out.println(s1 == s2);//false,因为一个是堆内存中的 String 对象一个是常量池中的 String 对象,
System.out.println(s3 == s2);//true,因为两个都是常量池中的 String 对象
把第二行和第三行互换顺序,依然是同样的结果。
字符串拼接:
String str1 = "str";
String str2 = "ing";
String str3 = "str" + "ing";//常量池中的对象
String str4 = str1 + str2; //在堆上创建的新的对象
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false
尽量避免多个字符串拼接,因为这样会重新创建对象。如果需要改变字符串的话,可以使用 StringBuilder 或者 StringBuffer。
-
常量字符串的“+”操作,编译阶段直接会合成为一个字符串。如string str=”JA”+”VA”,在编译阶段会直接合并成语句String str=”JAVA”,于是会去常量池中查找是否存在”JAVA”,从而进行创建或引用。
-
对于final字段,编译期直接进行了常量替换(而对于非final字段则是在运行期进行赋值处理的)。
final String str1=”ja”; final String str2=”va”; String str3=str1+str2;
在编译时,直接替换成了String str3=”ja”+”va”,根据第三条规则,再次替换成String str3=”JAVA”
-
常量字符串和变量拼接时(如:String str3=baseStr + “01”;)会调用stringBuilder.append()在堆上创建新的对象。
小问题
String s1 = new String(“abc”);这句话创建了几个字符串对象?
将创建 1 或 2 个字符串。如果池中已存在字符串常量“abc”,则只会在堆空间创建一个字符串常量“abc”。如果池中没有字符串常量“abc”,那么它将首先在池中创建,然后在堆空间中创建,因此将创建总共 2 个字符串对象。
验证:
String s1 = new String("abc");// 堆内存的地址值
String s2 = "abc";
System.out.println(s1 == s2);// 输出 false,因为一个是堆内存,一个是常量池的内存,故两者是不同的。
System.out.println(s1.equals(s2));// 输出 true
8 种基本类型的包装类和常量池
Java 基本类型的包装类的大部分都实现了常量池技术,即 Byte,Short,Integer,Long,Character,Boolean;前面 4 种包装类默认创建了数值[-128,127] 的相应类型的缓存数据,Character创建了数值在[0,127]范围的缓存数据,Boolean 直接返回True Or False。如果超出对应范围仍然会去创建新的对象。 为啥把缓存设置为[-128,127]区间?(参见issue/461)性能和资源之间的权衡。
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
private static class CharacterCache {
private CharacterCache(){}
static final Character cache[] = new Character[127 + 1];
static {
for (int i = 0; i < cache.length; i++)
cache[i] = new Character((char)i);
}
}
两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。
Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出 true
Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出 false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出 false
Integer 缓存源代码:
/**
*此方法将始终缓存-128 到 127(包括端点)范围内的值,并可以缓存此范围之外的其他值。
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
应用场景:
- Integer i1=40;Java 在编译的时候会直接将代码封装成 Integer i1=Integer.valueOf(40);,从而使用常量池中的对象。
- Integer i1 = new Integer(40);这种情况下会创建新的对象。
Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);//输出 false
Integer 比较更丰富的一个例子:
Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);
System.out.println("i1=i2 " + (i1 == i2)); // true
System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); // true
System.out.println("i1=i4 " + (i1 == i4)); // false
System.out.println("i4=i5 " + (i4 == i5)); // false
System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); // true
System.out.println("40=i5+i6 " + (40 == i5 + i6)); // true
解释:
语句 i4 == i5 + i6,因为+这个操作符不适用于 Integer 对象,首先 i5 和 i6 进行自动拆箱操作,进行数值相加,即 i4 == 40。然后 Integer 对象无法与数值进行直接比较,所以 i4 自动拆箱转为 int 值 40,最终这条语句转为 40 == 40 进行数值比较。
参考链接
- 《深入理解 Java 虚拟机:JVM 高级特性与最佳实践(第三版》
- Guide哥的笔记
- 几张图轻松理解String.intern()
垃圾收集器与内存分配策略
本章常见面试题
- 如何判断对象是否死亡(两种方法)。
- 简单的介绍一下强引用、软引用、弱引用、虚引用(虚引用与软引用和弱引用的区别、使用软引用能带来的好处)。
- 如何判断一个常量是废弃常量
- 如何判断一个类是无用的类
- 垃圾收集有哪些算法,各自的特点?
- HotSpot 为什么要分为新生代和老年代?
- 常见的垃圾回收器有哪些?
- 介绍一下 CMS,G1 收集器。
- Minor Gc 和 Full GC 有什么不同呢?
导论
当需要排查各种内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时,我们就需要对这些“自动化”的技术实施必要的监控和调节。
概述
Java内存区域中程序计数器、虚拟机栈、本地方法栈3个区域随着线程而生,随着线程而灭。每一个栈帧中分配多少内存基本上是在类结构确定下来就已知的,这几个区域的内存分配和回收都具备确定性,不需要过多考虑回收的问题,当方法结束或者线程结束时,内存自然就跟着回收了。
Java堆和方法区这两个内存区域则有很显著的不确定性,一个接口的多个实现类需要的内存可能会不一样,一个方法所执行的不同条件分支所需要的内存也可能不一样,只有处于运行期间,我们才能知道程序究竟会创建哪些对象,创建多少个对象,这部分内存分配和回收是动态的。垃圾收集器正是关注这部分内存。
JVM内存分配和回收基础
Java 的自动内存管理主要是针对对象内存的回收和对象内存的分配。同时,Java 自动内存管理最核心的功能是 堆 内存中对象的分配与回收。
Java 堆是垃圾收集器管理的主要区域,因此也被称作GC 堆(Garbage Collected Heap).从垃圾回收的角度,由于现在收集器基本都采用分代垃圾收集算法,所以 Java 堆还可以细分为:新生代和老年代:再细致一点有:Eden 空间、From Survivor、To Survivor 空间等。进一步划分的目的是更好地回收内存,或者更快地分配内存。
一些术语:
- 部分收集(Partial GC):指目标不是完整收集整个Java堆的垃圾,而且对部分区域收集。可细分为:
- 新生代收集(Minor GC/Young GC)
- 老年代收集(Major GC/Old GC)
- 混合收集(Mixed GC):收集整个新生代以及部分老年代
- 整堆收集(Full GC):收集整个Java堆和方法区的垃圾
堆空间的基本结构:
上图所示的 eden 区、s0(“From”) 区、s1(“To”) 区都属于新生代,tentired 区属于老年代。大部分情况,对象都会首先在 Eden 区域分配,在一次新生代垃圾回收后,如果对象还存活,则会进入 s1(“To”),并且对象的年龄还会加 1(Eden 区->Survivor 区后对象的初始年龄变为 1),当它的年龄增加到一定程度(默认为 15 岁),就会被晋升到老年代中。对象晋升到老年代的年龄阈值,可以通过参数 -XX:MaxTenuringThreshold
来设置。经过这次GC后,Eden区和"From"区已经被清空。这个时候,“From"和"To"会交换他们的角色,也就是新的"To"就是上次GC前的“From”,新的"From"就是上次GC前的"To”。不管怎样,都会保证名为To的Survivor区域是空的。Minor GC会一直重复这样的过程,直到“To”区被填满,"To"区被填满之后,会将所有对象移动到老年代中。
对象优先在 eden 区分配
目前主流的垃圾收集器都会采用分代回收算法,因此需要将堆内存分为新生代和老年代,这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
大多数情况下,对象在新生代中 eden 区分配。当 eden 区没有足够空间进行分配时,虚拟机将发起一次 Minor GC,如果当Minor GC后eden区依然没有足够的空间进行分配,只好通过分配担保机制 把新生代的对象提前转移到老年代中去;如果执行分配担保机制后eden区依然存不下该对象,则再老年代分配;如果能存在,则继续在eden区分配。
Minor GC 和 Full GC 有什么不同呢?
- 新生代 GC(Minor GC):指发生新生代的的垃圾收集动作,Minor GC 非常频繁,回收速度一般也比较快。
- 老年代 GC(Major GC):指发生在老年代的 GC,出现了 Major GC 经常会伴随至少一次的 Minor GC(并非绝对),Major GC 的速度一般会比 Minor GC 的慢 10 倍以上。
大对象直接进入老年代
大对象就是需要大量连续内存空间的对象(比如:字符串、数组)。
为什么要这样呢?
为了避免为大对象分配内存时由于分配担保机制带来的复制而降低效率。
长期存活的对象将进入老年代
既然虚拟机采用了分代收集的思想来管理内存,那么内存回收时就必须能识别哪些对象应放在新生代,哪些对象应放在老年代中。为了做到这一点,虚拟机给每个对象一个对象年龄(Age)计数器。
如果对象在 Eden 出生并经过第一次 Minor GC 后仍然能够存活,并且能被 Survivor 容纳的话,将被移动到 Survivor 空间中,并将对象年龄设为 1.对象在 Survivor 中每熬过一次 MinorGC,年龄就增加 1 岁,当它的年龄增加到一定程度(默认为 15 岁),就会被晋升到老年代中。对象晋升到老年代的年龄阈值,可以通过参数 -XX:MaxTenuringThreshold
来设置。
动态对象年龄判定
虚拟机并不是永远要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代,如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半,则年龄大于或等于该年龄的对象可以直接进入老年代,无需等到 MaxTenuringThreshold 中要求的年龄。
空间分配担保
在发生 Minor GC 之前,虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间,如果条件成立的话,那么 Minor GC 可以确认是安全的。
如果不成立的话虚拟机会查看 HandlePromotionFailure 的值是否允许担保失败,如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小,如果大于,将尝试着进行一次 Minor GC;如果小于,或者 HandlePromotionFailure 的值不允许冒险,那么就要进行一次 Full GC。
Full GC 的触发条件
对于 Minor GC,其触发条件非常简单,当 Eden 空间满时,就将触发一次 Minor GC。而 Full GC 则相对复杂,有以下条件:
1. 调用 System.gc()
只是建议虚拟机执行 Full GC,但是虚拟机不一定真正去执行。不建议使用这种方式,而是让虚拟机管理内存。
2. 老年代空间不足
老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等。
为了避免以上原因引起的 Full GC,应当尽量不要创建过大的对象以及数组。除此之外,可以通过 -Xmn 虚拟机参数调大新生代的大小,让对象尽量在新生代被回收掉,不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄,让对象在新生代多存活一段时间。
3. 空间分配担保失败
使用复制算法的 Minor GC 需要老年代的内存空间作担保,如果担保失败会执行一次 Full GC。具体内容请参考上面的内容。
4. JDK 1.7 及以前的永久代空间不足
在 JDK 1.7 及以前,HotSpot 虚拟机中的方法区是用永久代实现的,永久代中存放的为一些 Class 的信息、常量、静态变量等数据。
当系统中要加载的类、反射的类和调用的方法较多时,永久代可能会被占满,在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了,那么虚拟机会抛出 java.lang.OutOfMemoryError。
为避免以上原因引起的 Full GC,可采用的方法为增大永久代空间或转为使用 CMS GC。
5. Concurrent Mode Failure
执行 CMS GC 的过程中同时有对象要放入老年代,而此时老年代空间不足(可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足),便会报 Concurrent Mode Failure 错误,并触发 Full GC。
对象已死?
堆中几乎放着所有的对象实例,对堆垃圾回收前的第一步就是要判断那些对象已经死亡(即不能再被任何途径使用的对象)。
下面介绍判断一个对象是否死亡的两种方法。
引用计数法
给对象中添加一个引用计数器,每当有一个地方引用它,计数器就加 1;当引用失效,计数器就减 1;任何时候计数器为 0 的对象就是不可能再被使用的。
这个方法实现简单,效率高,但是目前主流的虚拟机中并没有选择这个算法来管理内存,其最主要的原因是它很难解决对象之间相互循环引用的问题。 所谓对象之间的相互引用问题,如下面代码所示:除了对象 objA 和 objB 相互引用着对方之外,这两个对象之间再无任何引用。但是他们因为互相引用对方,导致它们的引用计数器都不为 0,于是引用计数算法无法通知 GC 回收器回收他们。
public class ReferenceCountingGc {
Object instance = null;
public static void main(String[] args) {
ReferenceCountingGc objA = new ReferenceCountingGc();
ReferenceCountingGc objB = new ReferenceCountingGc();
objA.instance = objB;
objB.instance = objA;
objA = null;
objB = null;
}
}
可达性分析算法
这个算法的基本思想就是通过一系列的称为 “GC Roots” 的对象作为起点,从这些节点开始向下搜索,节点所走过的路径称为引用链,当一个对象到 GC Roots 没有任何引用链相连的话,则证明此对象是不可用的。
GC Roots
在Java技术体系中,固定可作为GC Roots的对象包括以下几种:
- 在虚拟机栈中引用的对象,比如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。
- 在方法区中类静态属性引用的对象,比如Java类的引用类型静态变量。
- 在方法区中常量引用的对象,比如字符串常量池里的引用。
- 在本地方法栈中JNI(即通常所说的Native方法)引用的对象。
- Java虚拟机内部的引用,如基本类型对应的Class对象,一些常驻的异常对象(比如NullPointException)等,还有系统类加载器。
- 所有被同步锁(synchronized关键字)所持有的对象。
再谈引用
无论是通过引用计数法判断对象引用数量,还是通过可达性分析法判断对象的引用链是否可达,判定对象的存活都与“引用”有关。
JDK1.2 之前,Java 中引用的定义很传统:如果 reference 类型的数据存储的数值代表的是另一块内存的起始地址,就称这块内存代表一个引用。
JDK1.2 以后,Java 对引用的概念进行了扩充,将引用分为强引用、软引用、弱引用、虚引用四种(引用强度逐渐减弱)。
强引用
以前我们使用的大部分引用实际上都是强引用,这是使用最普遍的引用。如果一个对象具有强引用,那就类似于必不可少的生活用品,垃圾回收器绝不会回收它。当内存空间不足,Java 虚拟机宁愿抛出 OutOfMemoryError 错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题。
软引用
如果一个对象只具有软引用,那就类似于可有可无的生活用品。如果内存空间足够,垃圾回收器就不会回收它,如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,JAVA 虚拟机就会把这个软引用加入到与之关联的引用队列中。
弱引用
如果一个对象只具有弱引用,那就类似于可有可无的生活用品。弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程, 因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中。
应用
假如一个应用需要读取大量的本地图片,如果每次读取图片都从硬盘读取则会严重影响性能,如果一次性全部加装到内存中又可能造成内存溢出。这时可以用软引用或者弱引用解决这个问题。
Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();
WeakHashMap
import java.util.WeakHashMap;
/**
* @author wardseptember
* @create 2020-09-23 13:39
*/
public class WeakHashMapDemo {
public static void main(String[] args) {
myWeakHashMap();
}
private static void myWeakHashMap() {
WeakHashMap<Integer, String> map = new WeakHashMap<>();
Integer key = new Integer(1);
String value = "https://wardseptember.gitee.io";
map.put(key, value);
System.out.println(map);
key = null;
// 手动触发一次GC
System.gc();
System.out.println(map);
}
}
ReferenceQueue
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
/**
* @author wardseptember
* @create 2020-09-23 13:50
*/
public class WeakReferenceDemo {
public static void main(String[] args) {
Object o1 = new Object();
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
WeakReference<Object> weakReference = new WeakReference<>(o1, referenceQueue);
System.out.println(o1);
System.out.println(weakReference.get());
System.out.println(referenceQueue.poll());
System.out.println("==============");
o1 = null;
System.gc();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
// o1被回收前,会给referenceQueue发送一个通知
System.out.println(o1);
System.out.println(weakReference.get());
System.out.println(referenceQueue.poll());
}
}
虚引用
"虚引用"顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收。
虚引用主要用来跟踪对象被垃圾回收的活动。
为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知。
虚引用与软引用和弱引用的一个区别在于: 虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。
PhantomReference的get方法总是返回null。
特别注意,在程序设计中一般很少使用弱引用与虚引用,使用软引用的情况较多,这是因为软引用可以加速 JVM 对垃圾内存的回收速度,可以维护系统的运行安全,防止内存溢出(OutOfMemory)等问题的产生。
PhantomReference
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
/**
* @author wardseptember
* @create 2020-09-23 13:50
*/
public class PhantomReferenceDemo {
public static void main(String[] args) {
Object o1 = new Object();
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
PhantomReference<Object> phantomReference = new PhantomReference<>(o1, referenceQueue);
System.out.println(o1);
System.out.println(phantomReference.get());
System.out.println(referenceQueue.poll());
System.out.println("==============");
o1 = null;
System.gc();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
// o1被回收前,会给referenceQueue发送一个通知
System.out.println(o1);
System.out.println(phantomReference.get());
System.out.println(referenceQueue.poll());
}
}
生存还是死亡?
即使在可达性分析法中不可达的对象,也并非是“非死不可”的,这时候它们暂时处于“缓刑阶段”,要真正宣告一个对象死亡,至少要经历两次标记过程;如果对象在进行可达性分析后被判断为不可达对象,那它将会被第一次标记,随后进行一次筛选,筛选的条件是此对象是否有必要执行finalize()
方法。对象没有覆盖 finalize 方法,或 finalize 方法已经被虚拟机调用过时,虚拟机将这两种情况视为没有必要执行。
被判定为需要执行finalize()
方法的对象将会被放在一个队列中进行第二次标记,除非这个对象与引用链上的任何一个对象建立关联,否则就会被真的回收。finalize()
方法是对象逃脱回收的最后一次机会。自救只能进行一次,如果回收的对象之前调用了 finalize() 方法自救,后面回收时不会再调用该方法。
finalize()
类似 C++ 的析构函数,用于关闭外部资源。但是 try-finally 等方式可以做得更好,并且该方法运行代价很高,不确定性大,无法保证各个对象的调用顺序,因此最好不要使用。
回收方法区
方法区的垃圾收集主要回收废弃的常量和不再使用的类型。
如何判断一个常量是废弃常量
假如在常量池中存在数值“333” ,如果当前没有任何 int 引用该常量的话,就说明常量 “333" 就是废弃常量,如果这时发生内存回收的话而且有必要的话,”333" 就会被系统清理出常量池。
如何判断一个类是无用的类
- 该类所有的实例都已经被回收,也就是 Java 堆中不存在该类及其任何派生子类的实例。
- 加载该类的 ClassLoader 已经被回收。
- 该类对应的 java.lang.Class 对象没有在任何地方被引用,无法在任何地方通过反射访问该类的方法。
虚拟机可以对满足上述 3 个条件的无用类进行回收,这里说的仅仅是“可以”,而并不是和对象一样不使用了就会必然被回收。
OOM
Java.lang.StackOverflowError
栈溢出,栈里面存储的是方法的调用,上面有讲。
Java.lang.OutOfMemoryError: Java heap space
对象太多,堆溢出。
Java.lang.OutOfMemoryError: GC overhead limit exceeded
GC回收时间过长时会抛出OutOfMemroyError。过长的定义是,超过98%的时间用来做GC并且回收了不到2%的堆内存,连续多次GC都只回收了不到2%的内存的极端情况下才会抛出。CPU使用率一直是100%,而GC却没有任何成果。
Java.lang.OutOfMemoryError: Direct buffer memory
ByteBuffer.allocateDirect(capability)分配操作系统本地内存,不属于GC管辖范围。分配太多,可能导致 Direct buffer memory
Java.lang.OutOfMemoryError: unable to create new native thread
创建太多线程。
导致原因
- 一个应用进程创建了多个线程,超过系统承载极限。
- 服务器不允许你的应该程序创建这么多线程,linux系统默认允许单个进程可以创建的线程数是1024个。
解决办法
- 想办法降低你应用程序创建线程的数量,分析应用是否真的需要创建这么多线程,如果不是,改代码将线程数降到最低。
- 对于有的应用,确实需要创建很多线程,远超过linux系统的默认1024个线程的限制,可以通过修改linux服务器配置,扩大linux默认限制
Java.lang.OutOfMemoryError: Metaspace
Metaspace是方法区在HotSpot中的实现,使用的是本地内存,主要存储虚拟机加载的类信息、常量池、静态变量、即时编译后的代码等。
如果类太多,就报Java.lang.OutOfMemoryError: Metaspace.
垃圾收集算法
从如何判定对象消亡的角度出发,垃圾收集算法可以划分为“引用计数式垃圾收集”和“追踪式垃圾收集“。本文全部属于追踪式垃圾收集范畴。
分代收集理论
当前虚拟机的垃圾收集都采用分代收集算法,这种算法没有什么新的思想,只是根据对象存活周期的不同将内存分为几块。一般将 java 堆分为新生代和老年代,这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
比如在新生代中,每次收集都会有大量对象死去,所以可以选择复制算法,只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的,而且没有额外的空间对它进行分配担保,所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集。
标记-清除算法
该算法分为“标记”和“清除”阶段:首先标记出所有需要回收的对象,在标记完成后统一回收所有被标记的对象。它是最基础的收集算法,后续的算法都是对其不足进行改进得到。这种垃圾收集算法会带来两个明显的问题:
- 执行效率不稳定。如果Java堆中包含大量需要被回收的对象,这是必须进行大量的标记和清除动作,导致回收效率降低。
- 内存空间碎片化。标记、清除之后会产生大量不连续的内存碎片,空间碎片太多可能会导致当以后程序运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
标记-复制算法
为了解决标记-清除算法中的效率问题,“复制”收集算法出现了。它可以将内存分为大小相同的两块,每次使用其中的一块。当这一块的内存使用完后,就将还存活的对象复制到另一块去,然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。
缺点:
- 可用内存缩小为原来的一半,空间浪费明显。
- 当对象存活率高时,复制效率低。
标记-整理算法
根据老年代的特点提出的一种标记算法,标记过程仍然与“标记-清除”算法一样,但后续步骤不是直接对可回收对象回收,而是让所有存活的对象向一端移动,然后直接清理掉端边界以外的内存。
缺点:
- 如果移动存活对象,尤其是在老年代这种每次回收都有大量对象存活区域,这种移动操作必须全程暂停用户应用程序才能进行。
HotSpot的算法细节实现
此节暂时省略。
经典垃圾收集器
1.新生代的收集器包括
Serial
PraNew
Parallel Scavenge
2.老年代的收集器包括
Serial Old
Parallel Old
CMS
3.回收整个Java堆(新生代和老年代)
G1收集器
以上是 HotSpot 虚拟机中的 7 个垃圾收集器,连线表示垃圾收集器可以配合使用;图中收集器所处的区域,则表示它是属于新生代收集器或者是老年代收集器。
- 单线程与多线程:单线程指的是垃圾收集器只使用一个线程,而多线程使用多个线程;
- 串行与并行:串行指的是垃圾收集器与用户程序交替执行,这意味着在执行垃圾收集的时候需要停顿用户程序;并行指的是垃圾收集器和用户程序同时执行。除了 CMS 和 G1 之外,其它垃圾收集器都是以串行的方式执行。
Serial 收集器 Serial串行收集器-复制算法
Serial(串行)收集器收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 “单线程” 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作,更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程( “Stop The World” ),直到它收集结束。
总结
Serial有如下特点:
针对新生代;
采用复制算法;
单线程收集;
进行垃圾收集时,必须暂停所有工作线程,直到完成;
优势:
简单高效,由于采用的是单线程的方法,因此与其他类型的收集器相比,对单个cpu来说没有了上下文之间的的切换,效率比较高。
劣势:
会在用户不知道的情况下停止所有工作线程。
使用场景
Client 模式(桌面应用)
在用户的桌面应用场景中,可用内存一般不大,可以在较短时间内完成垃圾收集,只要不频繁发生,这是可以接受的
单核服务器
对于限定单个CPU的环境来说,Serial收集器没有线程切换开销,可以获得最高的单线程收集效率
参数设置
-XX:+UseSerialGC:添加该参数来显式的使用串行垃圾收集器
新生代采用复制算法,老年代采用标记-整理算法。
它的优点是简单高效,在单个 CPU 环境下,由于没有线程交互的开销,因此拥有最高的单线程收集效率。
它是 Client 场景下的默认新生代收集器,因为在该场景下内存一般来说不会很大。它收集一两百兆垃圾的停顿时间可以控制在一百多毫秒以内,只要不是太频繁,这点停顿时间是可以接受的。
ParNew 收集器 复制算法
它是 Serial 收集器的多线程版本。
它是 Server 场景下默认的新生代收集器,除了性能原因外,主要是因为除了 Serial 收集器,只有它能与 CMS 收集器配合使用。
自JDK 9开始,ParNew加CMS收集器的组合就不再是官方推荐的服务端模式下的收集器解决方案,官方希望G1(Garbage First)能完全取代它。
并行和并发概念补充:
- 并行(Parallel) :并行描述的是多条垃圾收集器线程之间的关系,指同一时间多条垃圾收集线程在协同工作,但此时用户线程仍然处于等待状态。
- 并发(Concurrent):指用户线程与垃圾收集线程同时执行(但不一定是并行,可能会交替执行),用户程序在继续运行,而垃圾收集器运行在另一个 CPU 上。
小结
优势:
多线程版本的Serial,可以更加有效的利用系统资源
劣势:
同Serial,会在用户不知道的情况下停止所有工作线程
使用场景
Server模式下使用,亮点是除Serial外,目前只有它能与CMS收集器配合工作,是一个非常重要的垃圾回收器。
参数设置
-XX:+UseConcMarkSweepGC:指定使用CMS后,会默认使用ParNew作为新生代收集器;
-XX:+UseParNewGC:强制指定使用ParNew;
-XX:ParallelGCThreads:指定垃圾收集的线程数量,ParNew默认开启的收集线程与CPU的数量相同;
Parallel Scavenge 收集器 (并行回收)收集器-复制算法
Parallel Scavenge 收集器也是使用复制算法的多线程收集器,它看上去几乎和ParNew都一样。 那么它有什么特别之处呢?
-XX:+UseParallelGC
使用 Parallel 收集器+ 老年代串行
-XX:+UseParallelOldGC
使用 Parallel 收集器+ 老年代并行
CMS 等垃圾收集器的目标是尽可能缩短垃圾收集时用户线程的停顿时间,而Parallel Scavenge的目标是达到一个可控制的吞吐量,因此它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户程序的时间占总时间的比值。
停顿时间越短就越适合需要与用户交互的程序,良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间,尽快完成程序的运算任务,适合在后台运算而不需要太多交互的任务。
缩短停顿时间是以牺牲吞吐量和新生代空间来换取的:新生代空间变小,垃圾回收变得频繁,导致吞吐量下降。
可以通过一个开关参数打开 GC 自适应的调节策略(GC Ergonomics),就不需要手工指定新生代的大小(-Xmn)、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。虚拟机会根据当前系统的运行情况收集性能监控信息,动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。
Parallel Scavenge 收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量,如果对于收集器运作不太了解的话,手工优化存在困难的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。
小结
有如下特点:
新生代收集器;
采用复制算法;
多线程收集;
关注点与其他收集器不同:
CMS等收集器的关注点是尽可能地缩短垃圾收集时用户线程的停顿时间;
而Parallel Scavenge收集器的目标则是达一个可控制的吞吐量;
优势:
追求高吞吐量,高效利用CPU,是吞吐量优先,且能进行精确控制。
劣势:
应该说是特点,追求高吞吐量必然要牺牲一些其他方面的优势,不能做到既,又。ParNew收集器关注点在于尽可能的缩短垃圾收集时用户线程的停顿时间,原本10s收集一次, 每次停顿100ms, 设置完参数之后可能变成5s收集一次, 每次停顿70ms. 停顿时间变短, 但收集次数变多。
使用场景
根据相关特性,我们很容易想到它的使用场景,即:当应用程序运行在具有多个CPU上,对暂停时间没有特别高的要求时,程序主要在后台进行计算,而不需要与用户进行太多交互等就特别适合ParNew收集器。
例如,那些执行批量处理、订单处理、工资支付、科学计算的应用程序等
参数设置
-XX:MaxGCPauseMillis:控制最大垃圾收集停顿时间,大于0的毫秒数;
-XX:GCTimeRatio:设置垃圾收集时间占总时间的比率,0<n<100的整数;
Serial Old 收集器 标记整理算法
Serial Old收集器是Serial 收集器的老年代版本,它同样是一个单线程收集器。它主要有两大用途:一种用途是在 JDK1.5 以及以前的版本中与 Parallel Scavenge 收集器搭配使用,另一种用途是作为 CMS 收集器发生失败时的后备方案。
小结
特点
Serial Old是Serial收集器的老年代版本,同样是一个单线程收集器,使用标记-整理算法。
有如下特点:
针对老年代;
采用"标记-整理"算法(还有压缩,Mark-Sweep-Compact);
单线程收集;
优劣势基本和Serial无异,它是和Serial收集器配合使用的老年代收集器。
使用场景
Client模式;
单核服务器;
与Parallel Scavenge收集器搭配;
作为CMS收集器的后备方案,在并发收集发生Concurrent Mode Failure时使用
Parallel Old收集器 收集器-标记整理算法
Parallel Scavenge 收集器的老年代版本。使用多线程和“标记-整理”算法。在注重吞吐量以及 CPU 资源的场合,都可以优先考虑 Parallel Scavenge 收集器和 Parallel Old 收集器。
特点:
针对老年代;
采用"标记-整理"算法;
多线程收集;
优劣势参考Parallel Scavenge收集器。
使用场景
JDK1.6及之后用来代替老年代的Serial Old收集器;
特别是在Server模式,多CPU的情况下;
这样在注重吞吐量以及CPU资源敏感的场景,就有了Parallel Scavenge(新生代)加Parallel Old(老年代)收集器的"给力"应用组合;
参数设置
-XX:+UseParallelOldGC:指定使用Parallel Old收集器
CMS 收集器 标记整理算法
CMS(Concurrent Mark Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户体验的应用上使用。
CMS(Concurrent Mark Sweep)收集器是 HotSpot 虚拟机第一款真正意义上的并发收集器,它第一次实现了让垃圾收集线程与用户线程(基本上)同时工作。
从名字中的Mark Sweep这两个词可以看出,CMS 收集器是一种 “标记-清除”算法实现的,它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤:
- 初始标记: 暂停所有的其他线程,并记录下直接与 root 相连的对象,速度很快 ;
- 并发标记: 进行 GC Roots Tracing 的过程,它在整个回收过程中耗时最长,不需要停顿。
- 重新标记: 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录,这个阶段的停顿时间一般会比初始标记阶段的时间稍长,远远比并发标记阶段时间短
- 并发清除: 开启用户线程,同时 GC 线程开始对未标记的区域做清扫
从它的名字就可以看出它是一款优秀的垃圾收集器,主要优点:并发收集、低停顿。但是它有下面三个明显的缺点:
- 吞吐量低:低停顿时间是以牺牲吞吐量为代价的,导致 CPU 利用率不够高。它会因为占用一部分线程而导致应用程序变慢,降低总吞吐量。
- **无法处理浮动垃圾;**浮动垃圾是指并发标记和并发清除阶段,由于用户线程继续运行而产生的垃圾,这部分垃圾只能到下一次 GC 时才能进行回收。由于用户线程还在继续运行,因此需要预留出一部分内存提供给用户线程使用,意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。如果预留的内存无法满足程序分配新对象的需要,就会出现 一次“并发失败”(Concurrent Mode Failure),这时虚拟机将临时启用 Serial Old 来替代 CMS收集老年代的垃圾。
- **它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。**往往出现老年代空间有剩余,但无法找到足够大连续空间来分配当前对象,不得不提前触发一次 Full GC。
小结
特点:
针对老年代;
基于"标记-清除"算法(不进行压缩操作,产生内存碎片);
以获取最短回收停顿时间为目标;
并发收集、低停顿;
需要更多的内存(看后面的缺点);
优势:
停顿时间短;
吞吐量大;
并发收集
劣势:
对CPU资源非常敏感
无法收集浮动垃圾
容易产生大量内存碎片
使用场景
与用户交互较多的场景;
希望系统停顿时间最短,注重服务的响应速度;
以给用户带来较好的体验;
如常见WEB、B/S系统的服务器上的应用。
参数设置
-XX:+UseConcMarkSweepGC:指定使用CMS收集器
G1 收集器
1.G1收集器-标记整理算法
JDK1.7后全新的回收器, 用于取代CMS收集器。
G1 (Garbage-First) 是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足 GC 停顿时间要求的同时,还具备高吞吐量性能特征.
堆被分为新生代和老年代,其它收集器进行收集的范围都是整个新生代或者老年代,而 G1 可以直接对新生代和老年代一起回收。
G1 把堆划分成多个大小相等的独立区域(Region),新生代和老年代不再物理隔离。
通过引入 Region 的概念,从而将原来的一整块内存空间划分成多个的小空间,使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性,使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间(这两个值是通过过去回收的经验获得),并维护一个优先列表,每次根据允许的收集时间,优先回收价值最大的 Region。
每个 Region 都有一个 Remembered Set,用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set,在做可达性分析的时候就可以避免全堆扫描。
如果不计算维护 Remembered Set 的操作,G1 收集器的运作大致可划分为以下几个步骤:
- 初始标记:仅仅是标记一下GC Roots能直接关联到的对象,并且修改TAMS指针的值,让下一阶段用户线程并发运行时,能正确地在可用的Region中分配新对象。这个阶段需要停顿,但耗时很短,并且是借用进行Minor GC的时候同步完成的,所以G1在这阶段实际上没有额外的停顿。每一个Region设计了两个名为TAMS(Top at Mark Start)的指针,把Region中的一部分空间划分出来用于并发回收过程中的新对象分配,并发回收时新分配的对象地址都必须在这两个指针位置上。
- 并发标记:从GC Root开始对堆中对象进行可达性分析,递归扫描整个堆里的对象图,找出要回收的对象,这阶段耗时较长,但可与用户程序并发执行。当对象图扫描完成以后,还要重新处理原始快照(SATB)记录下的在并发时有引用变动的对象。这是整个G1过程中,唯一不需要用户线程停顿的算法。
- 最终标记:为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录,虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面,最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程,但是可并行执行。
- 筛选回收:首先对各个 Region 中的回收价值和成本进行排序,根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行,但是因为只回收一部分 Region,时间是用户可控制的,而且停顿用户线程将大幅度提高收集效率。
G1被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具备一下特点:
- 空间整合:与 CMS 的“标记–清理”算法不同,G1 从整体来看是基于“标记整理”算法实现的收集器;从局部上来看是基于“复制”算法实现的;运行期间不会产生内存空间碎片。
- 可预测的停顿:这是 G1 相对于 CMS 的另一个大优势,降低停顿时间是 G1 和 CMS 共同的关注点,但 G1 除了追求低停顿外,还能建立可预测的停顿时间模型,能让使用者明确指定在一个长度为 M 毫秒的时间片段内。
- 区域化内存划片,整体编为一系列不连续的内存区域,避免了全内存区的GC操作。核心思想是将整个堆内存区域分成大小相同的子区域,在JVM启动时自动设置这些子区域的大小。
- 在堆的使用上,G1并不要求对象的存储一定是物理上连续的,只要逻辑上连续即可,每个分区也不会固定地为某个代服务,可以按需在新生代和老年代切换。启动时可以通过参数
-XX:G1HeapRegionSize=n
指定分区大小(1MB32MB,且必须是2的幂),默认将整堆划分为2048个分区。大小范围在1MB32MB,最多能设置2048个区域,也即最大能够支持的最大内存为:32MB * 2048 = 65536MB = 64内存。 - 在G1中,还有一种特效的区域,叫Humongous区域。如果一个对象占用的空间超过了分区容量50%以上,G1收集器就认为这是一个巨型对象。这些巨型对象默认直接会被分配在老年代,但是如果它是一个短期存在的巨型对象,就会对垃圾收集器造成负面影响。为了解决这个问题,G1划分了一个H区,它用来专门存放巨型对象。如果一个H区装不下一个巨型对象,那么G1会寻找连续的H分区来存储。为了能找到连续的H区,有时候不得不启动Full GC。
缺点:
- G1为了垃圾收集产生的内存占用和程序运行时的额外执行负载比CMS要高。
特点:
并行与并发
分代收集,收集范围包括新生代和老年代
结合多种垃圾收集算法,空间整合,不产生碎片
可预测的停顿:低停顿的同时实现高吞吐量
面向服务端应用,将来替换CMS
优势:
能充分利用多CPU、多核环境下的硬件优势;
能独立管理整个GC堆(新生代和老年代),而不需要与其他收集器搭配;
不会产生内存碎片,有利于长时间运行;
除了追求低停顿处,还能建立可预测的停顿时间模型;
G1收集器是当今收集器技术发展的最前沿成果。
劣势:
G1 需要记忆集 (具体来说是卡表)来记录新生代和老年代之间的引用关系,这种数据结构在 G1 中需要占用大量的内存,可能达到整个堆内存容量的 20% 甚至更多。而且 G1 中维护记忆集的成本较高,带来了更高的执行负载,影响效率。
按照《深入理解Java虚拟机》作者的说法,CMS 在小内存应用上的表现要优于 G1,而大内存应用上 G1 更有优势,大小内存的界限是6GB到8GB。
所以,尽管是最前沿的成果,也不是完美无缺的。
使用场景
个人以为G1已经基本全面压制cms、parallel等回收器,缺点见上面的劣势。但如果不是追求极致的性能,基本可以无脑G1
参数设置
-XX:+UseG1GC:指定使用G1收集器;
-XX:InitiatingHeapOccupancyPercent:当整个Java堆的占用率达到参数值时,开始并发标记阶段;默认为45;
-XX:MaxGCPauseMillis:为G1设置暂停时间目标,默认值为200毫秒;
-XX:G1HeapRegionSize:设置每个Region大小,范围1MB到32MB;目标是在最小Java堆时可以拥有约2048个Region;
ZGC
查看当前使用的垃圾收集器
java -XX:+PrintCommandLineFlags -version
一些参数
DefNew -----> Default New Generation
Tenured -----> Old
ParNew -----> Parallel New Generation
PsYoungGen -----> Parallel Scavenge
ParOldGen -----> Parallel Old Generation
配置垃圾收集器
使用串行垃圾收集器,老年代会自动使用Serial Old收集器:
java +XX:+UseSerialGC
启用ParNew收集器,老年代会使用Serial Old收集器:
java -XX:+UseParNewGC
启用Parallel Scavenge收集器,老年代自动使用Parallel Old收集器:
java -XX:+UseParallelGC # 或者下面这句
java -XX:+UseParallelOldGC
java -XX:ParallelGCThreads=8 # 表示启动8个GC线程
启用Concurrent Mark Sweep(CMS)收集器,新生代自动使用ParNew:
java -XX:+UseConcMarkSweepGC
开启该参数后,新生代使用ParNew,老年代使用CMS,如果CMS出错,将使用Serial Old代理CMS收集垃圾。
启用G1收集器:
java -XX:+UseG1GC
如何选择垃圾收集器
-
单CPU或者小内存,单机程序
-XX:+UseSerialGC
-
多CPU,需要大量吞吐量,如后台计算型
-XX:+UseParallelGC # 或者 -XX:+UseParallelOldGC
-
多CPU,追求低停顿时间,需要快速响应,如互联网应用
-XX:UseConcMarkSweepGC # 或者 -XX:+ParNewGC
低延迟垃圾收集器
衡量垃圾收集器的三项重要指标:
- 内存占用
- 吞吐量
- 延迟
随着计算机硬件的发展、性能的提升,延迟的重要性日益凸显。
Shenandoah和ZGC垃圾收集器,几乎整个工作过程全部都是并发的,只有初始标记、最终标记这些阶段有短暂的停顿,这部分停顿时间基本上是固定的,与堆的容量、堆中对象的数量没有正比例关系,停顿时间不超过10毫秒。
Shenandoah收集器
以后更新
ZGC收集器
以后更新
选择合适的垃圾收集器
Epsilon收集器
Epsilon收集器是一个不能进行垃圾收集的垃圾收集器。一个垃圾收集器除了垃圾收集这个本职工作之外,它还要负责堆的管理与布局、对象的分配、与解释器的协作、与编译器的协作、与监控子系统协作等职责。Epsilon收集器主要负责这部分工作。
JVM垃圾收集器总结
本文主要介绍了JVM中的垃圾回收器,主要包括串行回收器、并行回收器以及CMS回收器、G1回收器。他们各自都有优缺点,通常来说你需要根据你的业务,进行基于垃圾回收器的性能测试,然后再做选择。下面给出配置回收器时,经常使用的参数:
-XX:+UseSerialGC:在新生代和老年代使用串行收集器
-XX:+UseParNewGC:在新生代使用并行收集器
-XX:+UseParallelGC :新生代使用并行回收收集器,更加关注吞吐量
-XX:+UseParallelOldGC:老年代使用并行回收收集器
-XX:ParallelGCThreads:设置用于垃圾回收的线程数
-XX:+UseConcMarkSweepGC:新生代使用并行收集器,老年代使用CMS+串行收集器
-XX:ParallelCMSThreads:设定CMS的线程数量
-XX:+UseG1GC:启用G1垃圾回收器
JVM调优
JVM参数类型
标配参数
java -version
java -help
java -showversion
X参数
解释执行
java -Xint
第一次使用就编译成本地代码
java -Xcomp
混合模式
java -Xmixed
XX参数
Boolean类型
-XX:+ 或者 -某个属性值
+ 表示开启
- 表示关闭
查看正在运行的java程序:
jps -l
查看某个java程序的某个jvm参数是否开启:
jinfo -flag jvm参数 进程号
例如:
jinfo -flag PrintGCDetails 进程号 # 查看这个java程序是否开始GC日志
查看某个java程序的所有jvm参数:
jinfo -flags 进程号
是否使用串行垃圾回收器:
-XX:-UseSerialGC
+XX:+UseSerialGC
KV设值类型
-XX:属性key=属性值value
使用例子:
-XX:MetaspaceSize=128m # 设置元空间的大小
-XX:MaxTenuringThreshold=15 # 年轻代升老年代的阈值
-Xms等价于-XX:InitialHeapSize;-Xmx等价于-XX:MaxHeapSize
jinfo举例,如何查看当前运行程序的配置
查看jvm初始化参数:
java -XX:+PrintFlagsInitial
查看jvm修改更新后的参数:
java -XX:PrintFlagsFinal
":= "代表UseParallelGC被修改过,没有被修改就是“=”
查看参数:
java -XX:+PrintCommandLineFlags -version
JVM常用配置参数
-Xms 和 -Xmx
-Xms和-Xmx设置为一样大小,默认为物理内存的四分之一
-Xss
设置单个线程栈的大小,一般默认为512k~1024k
-Xss等价于-XX:ThreadStackSize
-Xmn
设置新生代的大小
-XX:MetaspaceSize
设置元空间大小
-XX:+PrintGCDetails
输出GC的详细信息
Minor GC
Full GC
设置参数案例
-Xms128m -Xms4096m -Xss1024k -XX:MetaspaceSize=512m -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseSerialGC
-XX:SurvivorRatio
新生代默认比例:
Eden :from survivor : to survivo = 8 : 1 : 1
jvm默认新生代参数:
-XX:SurvivorRatio=8
# 这就是上面的8:1:1
-XX:NewRatio
配置新生代和老年代在堆结构中的占比。
默认-XX:NewRatio=2,即新生代 : 老年代=1 : 2
-XX:MaxTenuringThreshold
设置新生代升老年代的阈值,默认是15,最大也是15,因为只用4bit存储这个值。
如何查看JVM系统默认值
类文件结构
概述
在 Java 中,JVM 可以理解的代码就叫做字节码
(即扩展名为 .class
的文件),它不面向任何特定的处理器,只面向虚拟机。Java 语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效,而且,由于字节码并不针对一种特定的机器,因此,Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。
Clojure(Lisp 语言的一种方言)、Groovy、Scala 等语言都是运行在 Java 虚拟机之上。下图展示了不同的语言被不同的编译器编译成.class
文件最终运行在 Java 虚拟机之上。.class
文件的二进制格式可以使用 WinHex 查看。
可以说.class
文件是不同的语言在 Java 虚拟机之间的重要桥梁,同时也是支持 Java 跨平台很重要的一个原因。
Class 文件结构总结
根据 Java 虚拟机规范,类文件由单个 ClassFile 结构组成:
ClassFile {
u4 magic; //Class 文件的标志
u2 minor_version;//Class 的小版本号
u2 major_version;//Class 的大版本号
u2 constant_pool_count;//常量池的数量
cp_info constant_pool[constant_pool_count-1];//常量池
u2 access_flags;//Class 的访问标记
u2 this_class;//当前类
u2 super_class;//父类
u2 interfaces_count;//接口
u2 interfaces[interfaces_count];//一个类可以实现多个接口
u2 fields_count;//Class 文件的字段属性
field_info fields[fields_count];//一个类会可以有个字段
u2 methods_count;//Class 文件的方法数量
method_info methods[methods_count];//一个类可以有个多个方法
u2 attributes_count;//此类的属性表中的属性数
attribute_info attributes[attributes_count];//属性表集合
}
下面详细介绍一下 Class 文件结构涉及到的一些组件。
Class文件字节码结构组织示意图 (之前在网上保存的,非常不错,原出处不明):
2.1 魔数
u4 magic; //Class 文件的标志
每个 Class 文件的头四个字节称为魔数(Magic Number),它的唯一作用是确定这个文件是否为一个能被虚拟机接收的 Class 文件。
程序设计者很多时候都喜欢用一些特殊的数字表示固定的文件类型或者其它特殊的含义。
2.2 Class 文件版本
u2 minor_version;//Class 的小版本号
u2 major_version;//Class 的大版本号
紧接着魔数的四个字节存储的是 Class 文件的版本号:第五和第六是次版本号,第七和第八是主版本号。
高版本的 Java 虚拟机可以执行低版本编译器生成的 Class 文件,但是低版本的 Java 虚拟机不能执行高版本编译器生成的 Class 文件。所以,我们在实际开发的时候要确保开发的的 JDK 版本和生产环境的 JDK 版本保持一致。
2.3 常量池
u2 constant_pool_count;//常量池的数量
cp_info constant_pool[constant_pool_count-1];//常量池
紧接着主次版本号之后的是常量池,常量池的数量是 constant_pool_count-1(常量池计数器是从1开始计数的,将第0项常量空出来是有特殊考虑的,索引值为0代表“不引用任何一个常量池项”)。
常量池主要存放两大常量:字面量和符号引用。字面量比较接近于 Java 语言层面的的常量概念,如文本字符串、声明为 final 的常量值等。而符号引用则属于编译原理方面的概念。包括下面三类常量:
- 类和接口的全限定名
- 字段的名称和描述符
- 方法的名称和描述符
常量池中每一项常量都是一个表,这14种表有一个共同的特点:开始的第一位是一个 u1 类型的标志位 -tag 来标识常量的类型,代表当前这个常量属于哪种常量类型.
类型 | 标志(tag) | 描述 |
---|---|---|
CONSTANT_utf8_info | 1 | UTF-8编码的字符串 |
CONSTANT_Integer_info | 3 | 整形字面量 |
CONSTANT_Float_info | 4 | 浮点型字面量 |
CONSTANT_Long_info | 5 | 长整型字面量 |
CONSTANT_Double_info | 6 | 双精度浮点型字面量 |
CONSTANT_Class_info | 7 | 类或接口的符号引用 |
CONSTANT_String_info | 8 | 字符串类型字面量 |
CONSTANT_Fieldref_info | 9 | 字段的符号引用 |
CONSTANT_Methodref_info | 10 | 类中方法的符号引用 |
CONSTANT_InterfaceMethodref_info | 11 | 接口中方法的符号引用 |
CONSTANT_NameAndType_info | 12 | 字段或方法的符号引用 |
CONSTANT_MothodType_info | 16 | 标志方法类型 |
CONSTANT_MethodHandle_info | 15 | 表示方法句柄 |
CONSTANT_InvokeDynamic_info | 18 | 表示一个动态方法调用点 |
.class
文件可以通过javap -v class类名
指令来看一下其常量池中的信息(javap -v class类名-> temp.txt
:将结果输出到 temp.txt 文件)。
2.4 访问标志
在常量池结束之后,紧接着的两个字节代表访问标志,这个标志用于识别一些类或者接口层次的访问信息,包括:这个 Class 是类还是接口,是否为 public 或者 abstract 类型,如果是类的话是否声明为 final 等等。
类访问和属性修饰符:
我们定义了一个 Employee 类
package top.snailclimb.bean;
public class Employee {
...
}
通过javap -v class类名
指令来看一下类的访问标志。
2.5 当前类索引,父类索引与接口索引集合
u2 this_class;//当前类
u2 super_class;//父类
u2 interfaces_count;//接口
u2 interfaces[interfaces_count];//一个类可以实现多个接口
类索引用于确定这个类的全限定名,父类索引用于确定这个类的父类的全限定名,由于 Java 语言的单继承,所以父类索引只有一个,除了 java.lang.Object
之外,所有的 java 类都有父类,因此除了 java.lang.Object
外,所有 Java 类的父类索引都不为 0。
接口索引集合用来描述这个类实现了那些接口,这些被实现的接口将按implents
(如果这个类本身是接口的话则是extends
) 后的接口顺序从左到右排列在接口索引集合中。
2.6 字段表集合
u2 fields_count;//Class 文件的字段的个数
field_info fields[fields_count];//一个类会可以有个字段
字段表(field info)用于描述接口或类中声明的变量。字段包括类级变量以及实例变量,但不包括在方法内部声明的局部变量。
field info(字段表) 的结构:
- access_flags: 字段的作用域(
public
,private
,protected
修饰符),是实例变量还是类变量(static
修饰符),可否被序列化(transient 修饰符),可变性(final),可见性(volatile 修饰符,是否强制从主内存读写)。 - name_index: 对常量池的引用,表示的字段的名称;
- descriptor_index: 对常量池的引用,表示字段和方法的描述符;
- attributes_count: 一个字段还会拥有一些额外的属性,attributes_count 存放属性的个数;
- attributes[attributes_count]: 存放具体属性具体内容。
上述这些信息中,各个修饰符都是布尔值,要么有某个修饰符,要么没有,很适合使用标志位来表示。而字段叫什么名字、字段被定义为什么数据类型这些都是无法固定的,只能引用常量池中常量来描述。
字段的 access_flags 的取值:
2.7 方法表集合
u2 methods_count;//Class 文件的方法的数量
method_info methods[methods_count];//一个类可以有个多个方法
methods_count 表示方法的数量,而 method_info 表示的方法表。
Class 文件存储格式中对方法的描述与对字段的描述几乎采用了完全一致的方式。方法表的结构如同字段表一样,依次包括了访问标志、名称索引、描述符索引、属性表集合几项。
method_info(方法表的) 结构:
方法表的 access_flag 取值:
注意:因为volatile
修饰符和transient
修饰符不可以修饰方法,所以方法表的访问标志中没有这两个对应的标志,但是增加了synchronized
、native
、abstract
等关键字修饰方法,所以也就多了这些关键字对应的标志。
2.8 属性表集合
u2 attributes_count;//此类的属性表中的属性数
attribute_info attributes[attributes_count];//属性表集合
在 Class 文件,字段表,方法表中都可以携带自己的属性表集合,以用于描述某些场景专有的信息。与 Class 文件中其它的数据项目要求的顺序、长度和内容不同,属性表集合的限制稍微宽松一些,不再要求各个属性表具有严格的顺序,并且只要不与已有的属性名重复,任何人实现的编译器都可以向属性表中写 入自己定义的属性信息,Java 虚拟机运行时会忽略掉它不认识的属性。
参考链接
虚拟机类加载机制
类的生命周期
一个类的完整生命周期如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PR2UnqcU-1624851354188)(http://wardseptember.top/20200818171655.png)]
类加载过程
Class 文件需要加载到虚拟机中之后才能运行和使用,那么虚拟机是如何加载这些 Class 文件呢?
系统加载 Class 类型的文件主要三步:加载->连接->初始化。连接过程又可分为三步:验证->准备->解析。
加载
class文件的加载时机:
- 1 遇到 new、getstatic、putstatic、或invokestatic这四条字节码指令 2 使用
java.lang.reflect 包的方法对类进行反射调用的时候 3 初始化类时,父类没有被初始化,先初始化父类
4 虚拟机启动时,用户指定的主类(包含main()的那个类)
5 当使用JDK1.7动态语言支持的时,如果一个java.lang.invoke.MethodHandle
实例最后解析的结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个方法句柄锁对应的类没有进行过初始化时
关于序号1的详细解释:
使用 new 关键字实例化对象时
读取类的静态变量时(被 final修饰,已在编译期把结果放入常量池的静态字段除外)
设置类的静态变量时
调用一个类的静态方法时
注意: newarray指令触发的只是数组类型本身的初始化,而不会导致其相关类型的初始化,比如,new String[]只会直接触发 String[]类的初始化,也就是触发对类[Ljava.lang.String的初始化,而直接不会触发String类的初始化。
生成这四条指令最常见的Java代码场景是:
对于这5种会触发类进行初始化的场景,虚拟机规范中使用了一个很强烈的限定语:“有且只有”,这5种场景中的行为称为对一个类进行主动引用。除此之外,所有引用类的方式都不会触发初始化,称为 被动引用。
需要特别指出的是,类的实例化和类的初始化是两个完全不同的概念:
类的实例化是指创建一个类的实例(对象)的过程;
类的初始化是指为类各个成员赋初始值的过程,是类生命周期中的一个阶段;
被动引用的三个场景:
通过子类引用父类的静态字段,不会导致子类初始化
public class Test1 {
static {
System.out.println("Init Superclass!!!");
}
public static void main(String[] args) {
int x = Son.count;
}
}
class Father extends Test1{
static int count = 1;
static {
System.out.println(“Init father!!!”);
}
}
class Son extends Father{
static {
System.out.println(“Init son!!!”);
}
}
输出:
Init Superclass!!!
Init father!!!
1
2
对于静态字段,只有直接定义这个字段的类才会被初始化,因此通过其子类来引用父类中定义的静态字段,只会触发父类的初始化而不会触发子类的初始化。至于是否要触发子类的加载和验证,在虚拟机中并未明确规定,这点取决于虚拟机的具体实现。对于Sun HotSpot虚拟机来说,可通过-XX:+TraceClassLoading参数观察到此操作会导致子类的加载。
上面的案例中,由于count字段是在Father类中定义的,因此该类会被初始化,此外,在初始化类Father的时候,虚拟机发现其父类Test1 还没被初始化,因此虚拟机将先初始化其父类Test1 ,然后初始化子类Father,而Son始终不会被初始化;
通过数组定义来引用类,不会触发此类的初始化
public class Test2 {
public static void main(String[] args) {
M[] m = new M[8];
}
}
class M{
static {
System.out.println(“Init M!!!”);
}
}
运行之后我们会发现没有输出 “Init M!!!”,说明没有触发类的初始化阶段
常量在编译阶段会存入调用类的常量池中,本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化
public class Test3 {
public static void main(String[] args) {
System.out.println(ConstClass.COUNT);
}
}
class ConstClass{
static final int COUNT = 1;
static{
System.out.println(“Init ConstClass!!!”);
}
}
上面代码运行后也没有输出 Init ConstClass!!!,这是因为虽然在Java源码中引用了ConstClass 类中的常量COUNT ,但其实在编译阶段通过常量传播优化,已经将常量的值 "1"存储到Test3 常量池中了,对常量ConstClass.COUNT的引用实际都被转化为Test3 类对自身常量池的引用了,也就是说,实际上Test3 的Class文件之中并没有ConstClass类的符号引用入口,这两个类在编译为Class文件之后就不存在关系
类加载过程的第一步,主要完成下面3件事情:
- 通过全类名获取定义此类的二进制字节流
- 将字节流所代表的静态存储结构转换为方法区的运行时数据结构
- 在内存中生成一个代表该类的 Class 对象,作为方法区这些数据的访问入口
虚拟机规范多上面这3点并不具体,因此是非常灵活的。比如:“通过全类名获取定义此类的二进制字节流” 并没有指明具体从哪里获取、怎样获取。比如:比较常见的就是从 ZIP 包中读取(日后出现的JAR、EAR、WAR格式的基础)、其他文件生成(典型应用就是JSP)等等。
一个非数组类的加载阶段(加载阶段获取类的二进制字节流的动作)是可控性最强的阶段,这一步我们可以去完成还可以自定义类加载器去控制字节流的获取方式(重写一个类加载器的 loadClass()
方法)。数组类型不通过类加载器创建,它由 Java 虚拟机直接创建。
类加载器、双亲委派模型也是非常重要的知识点,这部分内容会在后面的文章中单独介绍到。
加载阶段和连接阶段的部分内容是交叉进行的,加载阶段尚未结束,连接阶段可能就已经开始了。
验证
准备
准备阶段是正式为类变量分配内存并设置类变量初始值的阶段,这些内存都将在方法区中分配。对于该阶段有以下几点需要注意:
- 这时候进行内存分配的仅包括类变量(static),而不包括实例变量,实例变量会在对象实例化时随着对象一块分配在 Java 堆中。
- 这里所设置的初始值"通常情况"下是数据类型默认的零值(如0、0L、null、false等),比如我们定义了
public static int value=111
,那么 value 变量在准备阶段的初始值就是 0 而不是111(初始化阶段才会赋值)。特殊情况:比如给 value 变量加上了 fianl 关键字public static final int value=111
,那么准备阶段 value 的值就被赋值为 111。
基本数据类型的零值:
解析
解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符7类符号引用进行。
符号引用就是一组符号来描述目标,可以是任何字面量。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。在程序实际运行时,只有符号引用是不够的,举个例子:在程序执行方法时,系统需要明确知道这个方法所在的位置。Java 虚拟机为每个类都准备了一张方法表来存放类中所有的方法。当需要调用一个类的方法的时候,只要知道这个方法在方发表中的偏移量就可以直接调用该方法了。通过解析操作符号引用就可以直接转变为目标方法在类中方法表的位置,从而使得方法可以被调用。
综上,解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程,也就是得到类或者字段、方法在内存中的指针或者偏移量。
初始化
初始化是类加载的最后一步,也是真正执行类中定义的 Java 程序代码(字节码),初始化阶段是执行类构造器 <clinit> ()
方法的过程。
对于<clinit>()
方法的调用,虚拟机会自己确保其在多线程环境中的安全性。因为 <clinit>()
方法是带锁线程安全,所以在多线程环境下进行类初始化的话可能会引起死锁,并且这种死锁很难被发现。
主动引用
对于初始化阶段,虚拟机严格规范了有且只有5种情况下,必须对类进行初始化(只有主动去使用类才会初始化类):
- 当遇到 new 、 getstatic、putstatic或invokestatic 这4条直接码指令时,比如 new 一个类,读取一个静态字段(未被 final 修饰)、或调用一个类的静态方法时。
- 当jvm执行new指令时会初始化类。即当程序创建一个类的实例对象。
- 当jvm执行getstatic指令时会初始化类。即程序访问类的静态变量(不是静态常量,常量会被加载到运行时常量池)。
- 当jvm执行putstatic指令时会初始化类。即程序给类的静态变量赋值。
- 当jvm执行invokestatic指令时会初始化类。即程序调用类的静态方法。
- 使用
java.lang.reflect
包的方法对类进行反射调用时如Class.forname("…"),newInstance()等等。 ,如果类没初始化,需要触发其初始化。 - 初始化一个类,如果其父类还未初始化,则先触发该父类的初始化。
- 当虚拟机启动时,用户需要定义一个要执行的主类 (包含 main 方法的那个类),虚拟机会先初始化这个类。
- MethodHandle和VarHandle可以看作是轻量级的反射调用机制,而要想使用这2个调用, 就必须先使用findStaticVarHandle来初始化要调用的类。
- 当一个接口中定义了JDK8新加入的默认方法(被default关键字修饰的接口方法)时,如果有这个接口的实现类发生了初始化,那该接口要在其之前被初始化。
被动引用
以上6 种场景中的行为称为对一个类进行主动引用。除此之外,所有引用类的方式都不会触发初始化,称为被动引用。被动引用的常见例子包括:
- 通过子类引用父类的静态字段,不会导致子类初始化。
System.out.println(SubClass.value); // value 字段在 SuperClass 中定义Copy to clipboardErrorCopied
- 通过数组定义来引用类,不会触发此类的初始化。该过程会对数组类进行初始化,数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类,其中包含了数组的属性和方法。
SuperClass[] sca = new SuperClass[10];Copy to clipboardErrorCopied
- 常量在编译阶段会存入调用类的常量池中,本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化。
System.out.println(ConstClass.HELLOWORLD);
卸载
卸载类即该类的Class对象被GC。
卸载类需要满足3个要求:
- 该类的所有的实例对象都已被GC,也就是说堆不存在该类的实例对象。
- 该类没有在其他任何地方被引用
- 该类的类加载器的实例已被GC
所以,在JVM生命周期类,由jvm自带的类加载器加载的类是不会被卸载的。但是由我们自定义的类加载器加载的类是可能被卸载的。
只要想通一点就好了,jdk自带的BootstrapClassLoader,PlatformClassLoader,AppClassLoader负责加载jdk提供的类,所以它们(类加载器的实例)肯定不会被回收。而我们自定义的类加载器的实例是可以被回收的,所以使用我们自定义加载器加载的类是可以被卸载掉的。
参考链接
类加载器
所有的类都由类加载器加载,加载的作用就是将 .class文件加载到内存。
JVM 中内置了三个重要的 ClassLoader,除了 BootstrapClassLoader 其他类加载器均由 Java 实现且全部继承自java.lang.ClassLoader
:
- BootstrapClassLoader(启动类加载器) :最顶层的加载类,由C++实现,负责加载
%JAVA_HOME%/lib
目录下的jar包和类或者或被-Xbootclasspath
参数指定的路径中的所有类。 - ExtensionClassLoader(扩展类加载器) :主要负责加载目录
%JRE_HOME%/lib/ext
目录下的jar包和类,或被java.ext.dirs
系统变量所指定的路径下的jar包。 - AppClassLoader(应用程序类加载器) :面向我们用户的加载器,负责加载当前应用classpath下的所有jar包和类。
双亲委派模型
每一个类都有一个对应它的类加载器。系统中的 ClassLoder 在协同工作的时候会默认使用 双亲委派模型 。即在类加载的时候,系统会首先判断当前类是否被加载过。已经被加载的类会直接返回,否则才会尝试加载。加载的时候,首先会把该请求委派该父类加载器的 loadClass()
处理,因此所有的请求最终都应该传送到顶层的启动类加载器 BootstrapClassLoader
中。当父类加载器无法处理时,才由自己来处理。当父类加载器为null时,会使用启动类加载器 BootstrapClassLoader
作为父类加载器。
每个类加载都有一个父类加载器,我们通过下面的程序来验证。
public class ClassLoaderDemo {
public static void main(String[] args) {
System.out.println("ClassLodarDemo's ClassLoader is " + ClassLoaderDemo.class.getClassLoader());
System.out.println("The Parent of ClassLodarDemo's ClassLoader is " + ClassLoaderDemo.class.getClassLoader().getParent());
System.out.println("The GrandParent of ClassLodarDemo's ClassLoader is " + ClassLoaderDemo.class.getClassLoader().getParent().getParent());
}
}
Output
ClassLodarDemo's ClassLoader is sun.misc.Launcher$AppClassLoader@18b4aac2
The Parent of ClassLodarDemo's ClassLoader is sun.misc.Launcher$ExtClassLoader@1b6d3586
The GrandParent of ClassLodarDemo's ClassLoader is null
AppClassLoader
的父类加载器为ExtClassLoader
ExtClassLoader
的父类加载器为null,null并不代表ExtClassLoader
没有父类加载器,而是 BootstrapClassLoader
。
其实这个双亲翻译的容易让别人误解,我们一般理解的双亲都是父母,这里的双亲更多地表达的是“父母这一辈”的人而已,并不是说真的有一个 Mother ClassLoader 和一个 Father ClassLoader 。另外,类加载器之间的“父子”关系也不是通过继承来体现的,是由“优先级”来决定。官方API文档对这部分的描述如下:
The Java platform uses a delegation model for loading classes. The basic idea is that every class loader has a “parent” class loader. When loading a class, a class loader first “delegates” the search for the class to its parent class loader before attempting to find the class itself.
双亲委派模型实现源码分析
双亲委派模型的实现代码非常简单,逻辑非常清晰,都集中在 java.lang.ClassLoader
的 loadClass()
中,相关代码如下所示。
private final ClassLoader parent;
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 首先,检查请求的类是否已经被加载过
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {//父加载器不为空,调用父加载器loadClass()方法处理
c = parent.loadClass(name, false);
} else {//父加载器为空,使用启动类加载器 BootstrapClassLoader 加载
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
//抛出异常说明父类加载器无法完成加载请求
}
if (c == null) {
long t1 = System.nanoTime();
//自己尝试加载
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
双亲委派模型的好处
双亲委派模型保证了Java程序的稳定运行,可以避免类的重复加载(JVM 区分不同类的方式不仅仅根据类名,相同的类文件被不同的类加载器加载产生的是两个不同的类),也保证了 Java 的核心 API 不被篡改。如果没有使用双亲委派模型,而是每个类加载器加载自己的话就会出现一些问题,比如我们编写一个称为 java.lang.Object
类的话,那么程序运行的时候,系统就会出现多个不同的 Object
类。
- 避免类的重复加载
- 打破双亲委派模型,实现类之间的隔离,还可以实现热部署
如果我们不想用双亲委派模型怎么办?
自定义加载器的话,需要继承 ClassLoader
。如果我们不想打破双亲委派模型,就重写 ClassLoader
类中的 findClass()
方法即可,无法被父类加载器加载的类最终会通过这个方法被加载。但是,如果想打破双亲委派模型则需要重写 loadClass()
方法
自定义类加载器
除了 BootstrapClassLoader
其他类加载器均由 Java 实现且全部继承自java.lang.ClassLoader
。如果我们要自定义自己的类加载器,很明显需要继承 ClassLoader
。
tomcat 为什么打破双亲委派模型
我们思考一下:Tomcat是个web容器, 那么它要解决什么问题:
- 一个web容器可能需要部署两个应用程序,不同的应用程序可能会依赖同一个第三方类库的不同版本,不能要求同一个类库在同一个服务器只有一份,因此要保证每个应用程序的类库都是独立的,保证相互隔离。
- 部署在同一个web容器中相同的类库相同的版本可以共享。否则,如果服务器有10个应用程序,那么要有10份相同的类库加载进虚拟机,这是扯淡的。
- web容器也有自己依赖的类库,不能于应用程序的类库混淆。基于安全考虑,应该让容器的类库和程序的类库隔离开来。
- web容器要支持jsp的修改,我们知道,jsp 文件最终也是要编译成class文件才能在虚拟机中运行,但程序运行后修改jsp已经是司空见惯的事情,否则要你何用? 所以,web容器需要支持 jsp 修改后不用重启。
参考链接
JVM调优
概述
为什么调优
- 防止出现OOM
- 解决OOM
- 减少Full GC出现的频率
性能优化的步骤
-
性能监控
- GC 频繁
- cpu load 过高
- OOM
- 内存泄露
- 死锁
- 程序响应时间较长
-
性能优化
- 打印GC日志,通过GCviewer或者http://gceasy.io 来分析日志信息
- 灵活运用命令行工具,jstack、jmap、jinfo等
- dump出堆文件,使用内存分析工具分析文件
- 使用阿里Arthas,或jconsole、JVisualVM来实时查看JVM状态
- jstack查看堆栈信息
-
性能调优
- 适当增加内存,根据业务背景选择垃圾收集器
- 优化代码,控制内存使用
- 增加机器,分散节点压力
- 合理设置线程池线程数量
- 使用中间件提高程序效率,比如缓存、消息队列
性能评价指标
-
停顿时间
提交请求和返回该请求的响应之间使用的时间,一般比较关注平均响应时间。
常用操作的响应时间列表:
在垃圾回收环节中:
暂停时间:执行垃圾收集时,程序的工作线程被暂停的时间。
-
吞吐量
对单位时间内完成的工作量的量度。
在GC中,吞吐量指运行用户代码的时间占总运行时间的比例,吞吐量为1-1/(1+n)。
-XX:GCTimeRatio=n
-
并发数
同一时刻,对服务器有实际交互的请求数
-
内存占用
Java堆区所占的内存大小
性能监控及诊断工具
jps
Jps(Java Process Status)可以显示指定系统内所有的HotSpot虚拟机内正在运行的进程。
基本语法
Jps [options] [hostid]
options参数如下图:
![](https://i-blog.csdnimg.cn/blog_migrate/5f7fcdd237a72751c6b11b3a344aa1a6.png)
jstat
jstat(JVM Statistics Monitoring Tool)查看JVM统计信息
基本语法
jstat -<option> [-t] [-h<lines] <vmid> [<interval [<count>]]
Jstat -h 查看命令相关参数
![](https://i-blog.csdnimg.cn/blog_migrate/972c21dd3d8a814b5e4fffc4d96df157.png)
![](https://i-blog.csdnimg.cn/blog_migrate/31ba6b8bfa76e5e2b288e42b4ee4944c.png)
- -h3表示每输出三行打印一遍表头
- vmid指定进程id
- interval是查看间隔,单位毫秒
- count是输出多少次
- -t可以再输出信息前加一个Timestamp列,显示程序的运行时间,单位是秒
判断内存泄露
![](https://i-blog.csdnimg.cn/blog_migrate/1159eda50c8028313c1a3d9ad0504086.png)
jinfo
Jinfo(Configuration Info for Java) 查看虚拟机配置参数信息,也可用于调整虚拟机的配置参数。
基本语法
Jinfo [options] pid
![](https://i-blog.csdnimg.cn/blog_migrate/40df928f7d71ebde32bb7d0cf64ef0d1.png)
![](https://i-blog.csdnimg.cn/blog_migrate/3b3cb3b9d4ecbd031005afe294be6e99.png)
jmap
Jmap(JVM Memory Map):一方面是获取dump文件(堆转储快照文件,二进制文件),它还可以获取目标Java进程的内存相关信息,包括Java堆各区域的使用情况、堆中对象的统计信息、类加载信息等。
![](https://i-blog.csdnimg.cn/blog_migrate/e2726ab4513f0d8c5da6f3852fb670ad.png)
![](https://i-blog.csdnimg.cn/blog_migrate/569fbe5f23579a803cc260996fcc50e1.png)
导出内存映像文件
![](https://i-blog.csdnimg.cn/blog_migrate/9e828fe0b3d5dda471fc0904d9b67bb5.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ed90033a2935f1e5fc2cab542161c4dc.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4438e98265bbe06d9fd8e5c892a32370.png)
显示堆内存相关信息
- Jmap -heap pid
- Jmap -histo pid
- Jmap -permstat pid 查看系统的ClassLoader信息
- Jmap -finalizerinfo 查看堆积在finalizer队列中的对象
![](https://i-blog.csdnimg.cn/blog_migrate/61b9f3eede4e96d0998bfc67c1816170.png)
jat
Jhat(JVM Heap Analysis Tool)是JDK自带的堆分析工具
![](https://i-blog.csdnimg.cn/blog_migrate/1d506257dd38c2734b645a3721f2d1e7.png)
基本语法
jhat [option] [dumpfile]
![](https://i-blog.csdnimg.cn/blog_migrate/dcbbc8082d8e1b81adeb3cdd68526d04.png)
Jstack(JVM Stack Trace)
Jstack:用于生成虚拟机指定进程当前时刻的线程快照(虚拟机堆栈跟踪)。线程快照就是当前虚拟机内指定进程的每一条线程正在执行的方法堆栈的集合。
![](https://i-blog.csdnimg.cn/blog_migrate/b053b444db7d428f71e265e6fb6e0389.png)
![](https://i-blog.csdnimg.cn/blog_migrate/613824f7512f0ee75430a8f503c4f49f.png)
jcmd
![](https://i-blog.csdnimg.cn/blog_migrate/425bf812ecebeeac8f0839cbd31f7474.png)
![](https://i-blog.csdnimg.cn/blog_migrate/c13b9828b2123f0e4a1c7529fcc0b174.png)
jstatd
![](https://i-blog.csdnimg.cn/blog_migrate/0077ac9a82cb59bb16ae3b56ce8a1fa8.png)
图形化工具
![](https://i-blog.csdnimg.cn/blog_migrate/371564dc7d89061ab3e74e9e011fb394.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4a9984632a54e3ab76f3111c6e9c1622.png)
![](https://i-blog.csdnimg.cn/blog_migrate/17c87d34f05b8753304b761c89b1492c.png)
Jconsole
![](https://i-blog.csdnimg.cn/blog_migrate/acd51042cedcdb300441ced07dc0034b.png)
Visual VM
![](https://i-blog.csdnimg.cn/blog_migrate/2bd4e3398848d624c0f1423e95abfaf5.png)
![](https://i-blog.csdnimg.cn/blog_migrate/280c6355749c8396a2dca8a9cfc23d4b.png)
![](https://i-blog.csdnimg.cn/blog_migrate/edc1820035de91f3628eafd7b4ad7c87.png)
主要功能
![](https://i-blog.csdnimg.cn/blog_migrate/4725e53d4bee09e4e7b56bdda81ad9b8.png)
MAT
![](https://i-blog.csdnimg.cn/blog_migrate/de608d2cc2e05493e7acb261b77eb88a.png)
![](https://i-blog.csdnimg.cn/blog_migrate/9242b075d7d963dce75584a4a8582ff8.png)
![](https://i-blog.csdnimg.cn/blog_migrate/137f814e705f5adcaed8804eb6aadc22.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b703fb50035998cd6eddabeacf90e2aa.png)
![](https://i-blog.csdnimg.cn/blog_migrate/577d72a85f0e9284918563e2ee2111eb.png)
tomcat
![](https://i-blog.csdnimg.cn/blog_migrate/54bee218bf49423adc336a340fc2f7e4.png)
JProfile
![](https://i-blog.csdnimg.cn/blog_migrate/e24c48173f1abe697e62fd75b500204a.png)
![](https://i-blog.csdnimg.cn/blog_migrate/58dc5da9ce7264973c911c245da9d137.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ac65ef092ed56591c34677a614652e7b.png)
![](https://i-blog.csdnimg.cn/blog_migrate/32a32e92c931707dc4bd92fa513af1ab.png)
![](https://i-blog.csdnimg.cn/blog_migrate/c9804c942f4ccccba06cab8528e8d756.png)
Arthas
![](https://i-blog.csdnimg.cn/blog_migrate/5e14ddddeaa48ae361c547aff5c4e724.png)
![](https://i-blog.csdnimg.cn/blog_migrate/bc3e1fff4dea6980c85f3242a2e1e8ab.png)
![](https://i-blog.csdnimg.cn/blog_migrate/567068cc8fe33f082668c571c5844724.png)
![](https://i-blog.csdnimg.cn/blog_migrate/48207f00d351ee2ccd7782e7fa68b3e0.png)
![](https://i-blog.csdnimg.cn/blog_migrate/2fe073c038925aae6d2bfc523b4ffd7d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/5aae0b8ca1c6297a63fc0ba2148c7ff5.png)
命令
![](https://i-blog.csdnimg.cn/blog_migrate/29b0bdeb7452b1da3fd1eb1759aec9c9.png)
![](https://i-blog.csdnimg.cn/blog_migrate/d7cf302e063362ed382e7ac1749beb5f.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ed32d1a7fdf49c028968710c872caf6a.png)
Java Mission Control
![](https://i-blog.csdnimg.cn/blog_migrate/fa3a6309538e082febc8080318d5040f.png)
![](https://i-blog.csdnimg.cn/blog_migrate/772547c024f0189029070d226b8e4d90.png)
![](https://i-blog.csdnimg.cn/blog_migrate/122bfd2e1383b0f9f63b24aaf21ee76a.png)
![](https://i-blog.csdnimg.cn/blog_migrate/3ca60af52d7be50d2f4320cf870512ba.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ac6cc24d0b06e580c24793279e0f969c.png)
![](https://i-blog.csdnimg.cn/blog_migrate/d04c74b7c0e923b8c111712064a3612e.png)
Flame Graphs
![](https://i-blog.csdnimg.cn/blog_migrate/04aa70efd73992561afc09833397c938.png)
Tprofiler
![](https://i-blog.csdnimg.cn/blog_migrate/38dbc5853b4584a69ce2707409242b6e.png)
内存泄露
![](https://i-blog.csdnimg.cn/blog_migrate/e5d35b39f50bf2eaa9ae75f0e319ae6f.png)
![](https://i-blog.csdnimg.cn/blog_migrate/24fe7ff5b47c6f66166a8be78446d9d9.png)
![](https://i-blog.csdnimg.cn/blog_migrate/77307961fee2b0bfe517d8ce3192816b.png)
![](https://i-blog.csdnimg.cn/blog_migrate/3cddf5602ce5a5e7e82b8041c1e5cd9c.png)
![](https://i-blog.csdnimg.cn/blog_migrate/df62b4fbe95890b6194447f32fbe21ed.png)
![](https://i-blog.csdnimg.cn/blog_migrate/59da704dbf0243cb426136a2240361fe.png)
静态集合类
![](https://i-blog.csdnimg.cn/blog_migrate/db6b42353710b019509c88c09556bb1d.png)
单例模式
![](https://i-blog.csdnimg.cn/blog_migrate/57963a90ad7e62c0b30dbbe665a5a5fc.png)
内部类持有外部类
![](https://i-blog.csdnimg.cn/blog_migrate/3b94b139f3109c60ff0ac40670ddde29.png)
各种连接
![](https://i-blog.csdnimg.cn/blog_migrate/1a99fed8cc5bc0050d717f8360a208de.png)
变量不合理的作用域
![](https://i-blog.csdnimg.cn/blog_migrate/f5d5c70b2dfefbb3cfedcf6dd2282d89.png)
改变哈希值
![](https://i-blog.csdnimg.cn/blog_migrate/05b5c183da70998b814d359d50a10156.png)
缓存泄漏
![](https://i-blog.csdnimg.cn/blog_migrate/51c180caa73967b940c545e1f5c6ba4a.png)
监听器和回调
![](https://i-blog.csdnimg.cn/blog_migrate/44c03cf5670000ad71c74889fac58b0c.png)
JVM运行时参数
![](https://i-blog.csdnimg.cn/blog_migrate/b45e170d9e38732394885ade85bc3444.png)
![](https://i-blog.csdnimg.cn/blog_migrate/374203d358b9fe2233c85fbfe18377ee.png)
![](https://i-blog.csdnimg.cn/blog_migrate/90a7e2fb41626abf14e8d03926d5efbb.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f4e1e0312689b06589bc52ed975e59b3.png)
![](https://i-blog.csdnimg.cn/blog_migrate/389afe89c447de5c9855e0016991a9be.png)
java -X
![](https://i-blog.csdnimg.cn/blog_migrate/a88d749d8f63f0f3a70f31877e99e41f.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ae0a7c42db7c6e800e7796bbd622c893.png)
![](https://i-blog.csdnimg.cn/blog_migrate/8701a6cacf2ce2f6467e7dfaeec86aa1.png)
![](https://i-blog.csdnimg.cn/blog_migrate/af2c2fba80d6fae98050d73568b8caad.png)
![](https://i-blog.csdnimg.cn/blog_migrate/aaea9dea65f9a2fb3e1f370f793f8a8d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f730078cb564a842ed03fcf3d634ac57.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b611d5b78da5bb1351a812ab0e6c2651.png)
![](https://i-blog.csdnimg.cn/blog_migrate/801c4d2a397fbaed48c7ce647a568a7f.png)
![](https://i-blog.csdnimg.cn/blog_migrate/e40ab08d412fee068b5fa3ad6d490741.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f9032b2ab7ff4be983a5012de0a7faec.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ced527261f65aaeeee9b8640410a3895.png)
![](https://i-blog.csdnimg.cn/blog_migrate/9d0080d96cbd56346ed356d3d1862fc7.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b2d0b3291803e6807dca0d13b502a3d0.png)
![](https://i-blog.csdnimg.cn/blog_migrate/07a7feac58286a824dc85d0f603d71ed.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4cc87dc92d5e61a66aff2c95818aeca5.png)
![](https://i-blog.csdnimg.cn/blog_migrate/2b6555ef87662802adfe00b7d149ba9d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/72983c36b7fe0c1ca50334048d46dcf0.png)
![](https://i-blog.csdnimg.cn/blog_migrate/9d88e5aeb5f15e773d2daa2d520c84aa.png)
![](https://i-blog.csdnimg.cn/blog_migrate/c36ce79332f10e479926e90ec0854d64.png)
![](https://i-blog.csdnimg.cn/blog_migrate/c04930ce1c1f6a75525c8ef462bdeaa8.png)
![](https://i-blog.csdnimg.cn/blog_migrate/acf2f7a865df59ee5243a26ee573c0c9.png)
![](https://i-blog.csdnimg.cn/blog_migrate/9b49dd09119d1e7bba6c0ef978b5967a.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f5fee6c1551e4b5a729b7d57ecd864c4.png)
![](https://i-blog.csdnimg.cn/blog_migrate/de84b311aef269bc95421a5158f23849.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b381ac181f19757d1bc1516d6ece0275.png)
![](https://i-blog.csdnimg.cn/blog_migrate/eef8b0fdb0253890c2aabedf71738702.png)
![](https://i-blog.csdnimg.cn/blog_migrate/a69d2d505998e1a04b089e24ae1f1107.png)
分析日志
![](https://i-blog.csdnimg.cn/blog_migrate/74cbbcf5a0b52cea32ae3cdf95f634b0.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b3f52e31ac15618fbcf563a13460f8be.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4f1811013c21ed87aa173d9fed038f3d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/9a4d34d29dd4d882feea6fa39a0607d6.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f8b0ab5f28f51321e0578e8edfa060af.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4d2ccfc340df363192dcbda4138ca1ac.png)
![](https://i-blog.csdnimg.cn/blog_migrate/704d0b4a3794d5c1115c7d31efe6092b.png)
Minor GC日志解析
![](https://i-blog.csdnimg.cn/blog_migrate/2eea0e6759623bddc25dacf6ae238c97.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ad0ef30510e0dff7f8f54b4a0fd24012.png)
![](https://i-blog.csdnimg.cn/blog_migrate/80c4cf4c969ca36710d9c9eb48a6cf67.png)
Full GC日志分析
![](https://i-blog.csdnimg.cn/blog_migrate/7a137558b172dd4ba58717eac545ba71.png)
![](https://i-blog.csdnimg.cn/blog_migrate/44b417f116d13f0917bc4842ad496af9.png)
![](https://i-blog.csdnimg.cn/blog_migrate/dda7bbd5561c5b9b359c8c6b3e6c90ad.png)
GC Easy
![](https://i-blog.csdnimg.cn/blog_migrate/99cbaee5c2e6fe60b5abc9ecdfc8d492.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f89c32b18fd3014d452ff60746920283.png)
GCViewer
![](https://i-blog.csdnimg.cn/blog_migrate/4c60b01bc487c5ec2c79ccbbcd95db12.png)
性能优化
![](https://i-blog.csdnimg.cn/blog_migrate/b2a07c6606a2fe6d6598c5ab5cba25ae.png)