JVM调优_堆内存溢出和非堆内存溢出
JVM调优_堆内存溢出和非堆内存溢出
文章目录
1. pom
2. MemoryController
3. User 对象
4. 动态生成class文件工具类
5. 启动项目
6. 测试连接
7. 异常信息
1. pom
asm
asm
3.3.1
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-devtools
runtime
true
org.projectlombok
lombok
true
2. MemoryController
package com.gblfy.chapter2;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@RestController
public class MemoryController {
private List userList = new ArrayList();
private List> classList = new ArrayList>();
/**
* 构造堆内存溢出
* 最大内存: -Xmx32M
* 最小内存: -Xms32M
* -Xmx32M -Xms32M
*/
@RequestMapping("/heap")
public void heap() {
int i = 0;
while (true) {
userList.add(new User(i++, UUID.randomUUID().toString()));
}
}
/**
* 构造非堆内存溢出
* 最大Metaspace: -XX:MaxMetaspaceSize=32M
* 最小Metaspace: -XX:MetaspaceSize=32M
* -XX:MetaspaceSize=32M -XX:MaxMetaspaceSize=32M
*/
@RequestMapping("/noheap")
public void noheap() {
while (true) {
classList.addAll(Metaspace.createClasses());
}
}
}
3. User 对象
package com.gblfy.chapter2;
import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class User {
private int id;
private String name;
}
4. 动态生成class文件工具类
package com.gblfy.chapter2;
import java.util.ArrayList;
import java.util.List;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
/*
*https://blog.csdn.net/bolg_hero/article/details/78189621
* 继承ClassLoader是为了方便调用defineClass方法，因为该方法的定义为protected
* */
public class Metaspace extends ClassLoader {
public static List> createClasses() {
// 类持有
List> classes = new ArrayList>();
// 循环1000w次生成1000w个不同的类。
for (int i = 0; i < 10000000; ++i) {
ClassWriter cw = new ClassWriter(0);
// 定义一个类名称为Class{i}，它的访问域为public，父类为java.lang.Object，不实现任何接口
cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "Class" + i, null,
"java/lang/Object", null);
// 定义构造函数方法
MethodVisitor mw = cw.visitMethod(Opcodes.ACC_PUBLIC, "",
"()V", null, null);
// 第一个指令为加载this
mw.visitVarInsn(Opcodes.ALOAD, 0);
// 第二个指令为调用父类Object的构造函数
mw.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object",
"", "()V");
// 第三条指令为return
mw.visitInsn(Opcodes.RETURN);
mw.visitMaxs(1, 1);
mw.visitEnd();
Metaspace test = new Metaspace();
byte[] code = cw.toByteArray();
// 定义类
Class> exampleClass = test.defineClass("Class" + i, code, 0, code.length);
classes.add(exampleClass);
}
return classes;
}
}
5. 启动项目
为了方便快速模拟，需要设置堆内存参数
6. 测试连接
测试堆内存溢出链接：
http://localhost/heap
测试非堆内存溢出链接：
http://localhost/noheap
7. 异常信息
JVM调优_堆内存溢出和非堆内存溢出相关教程

当新生代内存满的时候，促发垃圾回收，15岁的对象进入老年代，如果新生代频繁促发垃minor GC，会导致老年代内存不够，触发full GC. 如果老年代的对象不能被回收，就会导致老年代内存溢出

                
                    

                    

                    
                    
                    
点击上方“Coder编程”，选择“置顶公众号”
技术文章第一时间送达！
在上一章中我们介绍了JVM运行时参数以及jstat指令相关内容：[JVM教程与调优] 什么是JVM运行时参数？。下面我们来介绍一下jmap+MAT内存溢出。
首先我们来介绍一下下JVM的内存结构。
JVM内存结构介绍
从图中我们可以看到，JVM的内存结构分为两大块。一块叫堆区，一块叫非堆区。
堆区又分为两大块，一块Young，一块叫Old。Young区又分为Survivor区和Eden区。Survivor区我们又分为S0与S1。可以结合下图进行理解
非堆区呢，是属于我们操作系统的本地内存。它是独立于我们堆区之外的。它在JDK1.8里面有一个新的名字，叫Metaspace。Metaspace里面还包含几个块，其中有一块就是CCS,还有一块是CodeCache。当然，在我们的Metaspace中还包含很多其他块，这里就不做扩展了。
接下来，我们来通过实战，来更加深入的理解JVM结构，以及出现JVM内存溢出的原因。
实战理解
我们通过spring.start快速来生成一个springboot项目。
如图，我们快速的创建一个springboot项目，并将其下载下来。
这里我使用Eclipse，小伙伴们也可以使用IDEA或者其他开发工具也是可以的。
这里我们使用的是SpringBoot工程，如果有的小伙伴对SpringBoot还不太熟悉的，可以上网找一些教程先学习了解一下。
堆内存溢出演示
那么我们如何来构建一个堆内存溢出呢？其实很简单，我们只要定义一个List对象，然后通过一个循环不停的往List里面塞对象。因为只要Controller不被回收，那么它里面的成员变量也是不会被回收的。这样就会导致List里面的对象越来越多，占用的内存越来越大，最后就把我们的内存撑爆了。
创建User对象 
这里我们先创建一个User对象。
/**
 * 
　 * <p>Title: User</p>
　 * <p>Description: </p>
　 * @author Coder编程
　 * @date 2020年3月29日
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;

}
这里面@Data、@AllArgsConstructor、@NoArgsConstructor用的是lombok注解。不会使用的小伙伴，可以在网上查找相关资料学习一下。
创建Controller对象 
接下来我们来创建一个Controller来不停的往List集合中塞对象。
/**
 * 
　 * <p>Title: MemoryController</p>
　 * <p>Description: </p>
　 * @author Coder编程
　 * @date 2020年3月29日
 */
@RestController
public class MemoryController {

    private List<User>  userList = new ArrayList<User>();

    /**
     * -Xmx32M -Xms32M
     * */
    @GetMapping("/heap")
    public String heap() {
        int i=0;
        while(true) {
            userList.add(new User(i++, UUID.randomUUID().toString()));
        }
    }

}
为了更快达到我们的效果，我们来设置两个参数。
-Xmx32M -Xms32M
一个最大内存，一个最小内存。我们的堆就只有32M，这样就很容易溢出。
访问测试 
启动时候设置内存参数。
记得选中我们的Arguments，在JVM 参数中，将我们的值设置进去。最后点击Run运行起来。
然后我们在浏览器中请求：
http://localhost:8080/heap
我们再观察控制台打印：

通过打印结果，我们可以看到堆内存溢出了。
注意：
这里我们测试的时候可以很简单的看出在哪里出现的问题，但是在实际生产环境中并没有那么简单，因此我们需要借助工具，来定位这些问题。后续我们来介绍一下。
非堆内存溢出演示
接下来我们来演示一下非堆内存溢出，我们继续沿用上方代码。
非堆内存主要是MataSpace，那么我们如何构建一个非堆内存溢出呢？
我们知道MataSpace主要存一些class，filed，method等这些东西。
因此我们继续创建一个List集合，不断的往集合里面塞class。只要List不被回收，那么它里面的class也不会被回收。不停的往里面加之后，就会造成溢出。也就是我们的MataSpace溢出了。
如何来动态生成一些class呢？其实是有很多工具的，比如说：asm
引入asm工具包 
这里我们引入asm jar包。
<dependency>
    <groupId>asm</groupId>
    <artifactId>asm</artifactId>
    <version>3.3.1</version>
</dependency>
动态生成类文件 
还需要创建动态生成的类文件，这里我们就不做扩展介绍，有兴趣的小伙伴可以自行到网上查阅。
/**
 * 
　 * <p>Title: Metaspace</p>
　 * <p>Description: https://blog.csdn.net/bolg_hero/article/details/78189621
　 * 继承ClassLoader是为了方便调用defineClass方法，因为该方法的定义为protected</p>
　 * @author Coder编程
　 * @date 2020年3月29日
 */
public class Metaspace extends ClassLoader {

    public static List<Class<?>> createClasses() {
        // 类持有
        List<Class<?>> classes = new ArrayList<Class<?>>();
        // 循环1000w次生成1000w个不同的类。
        for (int i = 0; i < 10000000; ++i) {
            ClassWriter cw = new ClassWriter(0);
            // 定义一个类名称为Class{i}，它的访问域为public，父类为java.lang.Object，不实现任何接口
            cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "Class" + i, null,
                    "java/lang/Object", null);
            // 定义构造函数<init>方法
            MethodVisitor mw = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>",
                    "()V", null, null);
            // 第一个指令为加载this
            mw.visitVarInsn(Opcodes.ALOAD, 0);
            // 第二个指令为调用父类Object的构造函数
            mw.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object",
                    "<init>", "()V");
            // 第三条指令为return
            mw.visitInsn(Opcodes.RETURN);
            mw.visitMaxs(1, 1);
            mw.visitEnd();
            Metaspace test = new Metaspace();
            byte[] code = cw.toByteArray();
            // 定义类
            Class<?> exampleClass = test.defineClass("Class" + i, code, 0, code.length);
            classes.add(exampleClass);
        }
        return classes;
    }
}
创建Controller 
接下来我们再原Controller新增一个方法nonheap
/**
 * 
　 * <p>Title: MemoryController</p>
　 * <p>Description: </p>
　 * @author Coder编程
　 * @date 2020年3月29日
 */
@RestController
public class MemoryController {

    private List<User>  userList = new ArrayList<User>();
    private List<Class<?>>  classList = new ArrayList<Class<?>>();

    /**
     * -Xmx32M -Xms32M
     * */
    @GetMapping("/heap")
    public String heap() {
        int i=0;
        while(true) {
            userList.add(new User(i++, UUID.randomUUID().toString()));
        }
    }


    /**
     * -XX:MetaspaceSize=32M -XX:MaxMetaspaceSize=32M
     * */
    @GetMapping("/nonheap")
    public String nonheap() {
        while(true) {
            classList.addAll(Metaspace.createClasses());
        }
    }

}
访问测试 
这里我们同样在启动的时候也要设置Mataspace的值大小。
-XX:MetaspaceSize=32M -XX:MaxMetaspaceSize=32M
接着我们在浏览器中访问地址：localhost:8080/nonheap
以上我们就完成了对堆内存溢出以及非堆内存溢出的演示。
小插曲
在测试非堆内存溢出的时候，出现了另外一个错误。
java.lang.IncompatibleClassChangeError: Found interface org.objectweb.asm.MethodVisitor, but class was expected
这个异常另外写在java.lang.IncompatibleClassChangeError，小伙伴如果有遇到，可尝试一下是否能够解决
如何查看线上堆内存溢出以及非堆内存溢出
我们主要查看线上的内存映像文件来查看到底是哪里发生了内存溢出。
发生内存溢出的主要原因：
1.内存发生泄漏
2.内存分配不足
假如发生内存泄漏的话，我们就需要找到是哪个地方发生了内存泄漏，一直占用内存没有释放。
下面我们来看一下如何来导出我们的内存映像文件。
主要有两种方式。
1.内存溢出自动导出
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./
第一个参数表示：当发生内存溢出的时候，将内存溢出文件Dump出来。
第二个参数表示：Dump出来的文件存放的目录。
2.使用jmap命令手动导出
如果我们使用第一种命令，在发送内存溢出的时候再去导出，可能就有点晚了。我们可以等程序运行起来一段时间后，就可以使用jmap命令导出来进行分析。
演示内存溢出自动导出 
我们需要用到两个命令参数。
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./
我们接着运行项目，访问：localhost:8080/heap
查看一下打印结果。
可以看到，当发生了内存溢出后。输出了一个java_pid3972.hprof的文件。
在当前项目的当前文件中，我们就可以找到该文件。
演示jmap命令 
option:-heap,-clstats,-dump:,-F
参数都是什么意思呢？
live:只导出存活的对象，如果没有指定，则全部导出
format:导出文件的格式
file:导入的文件
我们刚才的程序还没有关闭，我们来看下程序的pid是多少。
输入：jps -l
我们将其文件导入到桌面中来，输入命令
jmap -dump:format=b,file=heap.hprof 3972
最后的3972是程序的pid。最后可以看到导出完毕。
还有其他的命令参数，小伙伴们可以去官网jmap指令查看如何使用。这里就不做过多介绍。
下一章节我们将通过命令实战定位JVM发生死循环、死锁问题。
推荐
[JVM教程与调优] 什么是JVM运行时参数？
[JVM教程与调优] 为什么要学习JVM虚拟机？
[JVM教程与调优] JVM都有哪些参数类型？
文末
文章收录至
Github: https://github.com/CoderMerlin/coder-programming
Gitee: https://gitee.com/573059382/coder-programming
欢迎关注并star~

				

![[JVM教程与调优] 了解JVM 堆内存溢出以及非堆内存溢出.png](https://upload-images.jianshu...
在上一章中我们介绍了JVM运行时参数以及jstat指令相关内容：[[JVM教程与调优] 什么是JVM运行时参数？](https://mp.weixin.qq.com/s?__...。下面我们来介绍一下jmap+MAT内存溢出。
首先我们来介绍一下下JVM的内存结构。
JVM内存结构介绍
从图中我们可以看到，JVM的内存结构分为两大块。一块叫堆区，一块叫非堆区。
堆区又分为两大块，一块Young，一块叫Old。Young区又分为Survivor区和Eden区。Survivor区我们又分为S0与S1。可以结合下图进行理解
非堆区呢，是属于我们操作系统的本地内存。它是独立于我们堆区之外的。它在JDK1.8里面有一个新的名字，叫Metaspace。Metaspace里面还包含几个块，其中有一块就是CCS,还有一块是CodeCache。当然，在我们的Metaspace中还包含很多其他块，这里就不做扩展了。
接下来，我们来通过实战，来更加深入的理解JVM结构，以及出现JVM内存溢出的原因。
实战理解
我们通过spring.start快速来生成一个springboot项目。
如图，我们快速的创建一个springboot项目，并将其下载下来。
这里我使用Eclipse，小伙伴们也可以使用IDEA或者其他开发工具也是可以的。
这里我们使用的是SpringBoot工程，如果有的小伙伴对SpringBoot还不太熟悉的，可以上网找一些教程先学习了解一下。
堆内存溢出演示
那么我们如何来构建一个堆内存溢出呢？其实很简单，我们只要定义一个List对象，然后通过一个循环不停的往List里面塞对象。因为只要Controller不被回收，那么它里面的成员变量也是不会被回收的。这样就会导致List里面的对象越来越多，占用的内存越来越大，最后就把我们的内存撑爆了。
创建User对象
这里我们先创建一个User对象。
/**
*
* 
Title: User
* 
Description: 
* @author Coder编程
* @date 2020年3月29日
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
}
这里面@Data、@AllArgsConstructor、@NoArgsConstructor用的是lombok注解。不会使用的小伙伴，可以在网上查找相关资料学习一下。
创建Controller对象
接下来我们来创建一个Controller来不停的往List集合中塞对象。
/**
*
* 
Title: MemoryController
* 
Description: 
* @author Coder编程
* @date 2020年3月29日
*/
@RestController
public class MemoryController {
private List  userList = new ArrayList();
/**
* -Xmx32M -Xms32M
* */
@GetMapping("/heap")
public String heap() {
int i=0;
while(true) {
userList.add(new User(i++, UUID.randomUUID().toString()));
}
}
}
为了更快达到我们的效果，我们来设置两个参数。
-Xmx32M -Xms32M
一个最大内存，一个最小内存。我们的堆就只有32M，这样就很容易溢出。
访问测试
启动时候设置内存参数。
记得选中我们的Arguments，在JVM 参数中，将我们的值设置进去。最后点击Run运行起来。
然后我们在浏览器中请求：
http://localhost:8080/heap
我们再观察控制台打印：
通过打印结果，我们可以看到堆内存溢出了。
注意：
这里我们测试的时候可以很简单的看出在哪里出现的问题，但是在实际生产环境中并没有那么简单，因此我们需要借助工具，来定位这些问题。后续我们来介绍一下。
非堆内存溢出演示
接下来我们来演示一下非堆内存溢出，我们继续沿用上方代码。
非堆内存主要是MataSpace，那么我们如何构建一个非堆内存溢出呢？
我们知道MataSpace主要存一些class，filed，method等这些东西。
因此我们继续创建一个List集合，不断的往集合里面塞class。只要List不被回收，那么它里面的class也不会被回收。不停的往里面加之后，就会造成溢出。也就是我们的MataSpace溢出了。
如何来动态生成一些class呢？其实是有很多工具的，比如说：asm
引入asm工具包
这里我们引入asm jar包。
asm
asm
3.3.1
动态生成类文件
还需要创建动态生成的类文件，这里我们就不做扩展介绍，有兴趣的小伙伴可以自行到网上查阅。
/**
*
* 
Title: Metaspace
* 
Description: https://blog.csdn.net/bolg_hero/article/details/78189621
* 继承ClassLoader是为了方便调用defineClass方法，因为该方法的定义为protected
* @author Coder编程
* @date 2020年3月29日
*/
public class Metaspace extends ClassLoader {
public static List> createClasses() {
// 类持有
List> classes = new ArrayList>();
// 循环1000w次生成1000w个不同的类。
for (int i = 0; i < 10000000; ++i) {
ClassWriter cw = new ClassWriter(0);
// 定义一个类名称为Class{i}，它的访问域为public，父类为java.lang.Object，不实现任何接口
cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "Class" + i, null,
"java/lang/Object", null);
// 定义构造函数方法
MethodVisitor mw = cw.visitMethod(Opcodes.ACC_PUBLIC, "",
"()V", null, null);
// 第一个指令为加载this
mw.visitVarInsn(Opcodes.ALOAD, 0);
// 第二个指令为调用父类Object的构造函数
mw.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object",
"", "()V");
// 第三条指令为return
mw.visitInsn(Opcodes.RETURN);
mw.visitMaxs(1, 1);
mw.visitEnd();
Metaspace test = new Metaspace();
byte[] code = cw.toByteArray();
// 定义类
Class> exampleClass = test.defineClass("Class" + i, code, 0, code.length);
classes.add(exampleClass);
}
return classes;
}
}
创建Controller
接下来我们再原Controller新增一个方法nonheap
/**
*
* 
Title: MemoryController
* 
Description: 
* @author Coder编程
* @date 2020年3月29日
*/
@RestController
public class MemoryController {
private List  userList = new ArrayList();
private List>  classList = new ArrayList>();
/**
* -Xmx32M -Xms32M
* */
@GetMapping("/heap")
public String heap() {
int i=0;
while(true) {
userList.add(new User(i++, UUID.randomUUID().toString()));
}
}
/**
* -XX:MetaspaceSize=32M -XX:MaxMetaspaceSize=32M
* */
@GetMapping("/nonheap")
public String nonheap() {
while(true) {
classList.addAll(Metaspace.createClasses());
}
}
}
访问测试
这里我们同样在启动的时候也要设置Mataspace的值大小。
-XX:MetaspaceSize=32M -XX:MaxMetaspaceSize=32M
接着我们在浏览器中访问地址：localhost:8080/nonheap
以上我们就完成了对堆内存溢出以及非堆内存溢出的演示。
小插曲
在测试非堆内存溢出的时候，出现了另外一个错误。
java.lang.IncompatibleClassChangeError: Found interface org.objectweb.asm.MethodVisitor, but class was expected
如何查看线上堆内存溢出以及非堆内存溢出
我们主要查看线上的内存映像文件来查看到底是哪里发生了内存溢出。
发生内存溢出的主要原因：
1.内存发生泄漏
2.内存分配不足
假如发生内存泄漏的话，我们就需要找到是哪个地方发生了内存泄漏，一直占用内存没有释放。
下面我们来看一下如何来导出我们的内存映像文件。
主要有两种方式。
1.内存溢出自动导出
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./
第一个参数表示：当发生内存溢出的时候，将内存溢出文件Dump出来。
第二个参数表示：Dump出来的文件存放的目录。
2.使用jmap命令手动导出
如果我们使用第一种命令，在发送内存溢出的时候再去导出，可能就有点晚了。我们可以等程序运行起来一段时间后，就可以使用jmap命令导出来进行分析。
演示内存溢出自动导出
我们需要用到两个命令参数。
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./
我们接着运行项目，访问：localhost:8080/heap
查看一下打印结果。
可以看到，当发生了内存溢出后。输出了一个java_pid3972.hprof的文件。
在当前项目的当前文件中，我们就可以找到该文件。
演示jmap命令
option:-heap,-clstats,-dump:,-F
参数都是什么意思呢？
live:只导出存活的对象，如果没有指定，则全部导出
format:导出文件的格式
file:导入的文件
我们刚才的程序还没有关闭，我们来看下程序的pid是多少。
输入：jps -l
我们将其文件导入到桌面中来，输入命令
jmap -dump:format=b,file=heap.hprof 3972
最后的3972是程序的pid。最后可以看到导出完毕。
还有其他的命令参数，小伙伴们可以去官网jmap指令查看如何使用。这里就不做过多介绍。
下一章节我们将通过命令实战定位JVM发生死循环、死锁问题。
推荐
文末