java溢出 事件触发_Java内存溢出和死锁的监控与分析

1.通过jstat命令进行查看堆内存使用情况

先随便启动一个(java的应用程序就行)Tomcat服务,在命令行里输入jps -l命令查看进程号

1.1 查看class加载统计

jstat -class 进程号

说明：

Loaded：加载class的数量

Bytes：所占用空间大小

Unloaded：未加载数量

Bytes：未加载占用空间

Time：时间

1.2查看编译统计

jstat -compiler 进程号

说明：

Compiled：编译数量。

Failed：失败数量

Invalid：不可用数量

Time：时间

FailedType：失败类型

FailedMethod：失败的方法

1.3垃圾回收统计

jstat -gc 进程号 间隔时间(毫秒) 打印次数

统计一次

每过1000毫秒统计一次,一共统计三次

说明:

S0C：第一个Survivor区的大小(KB)

S1C：第二个Survivor区的大小(KB)

S0U：第一个Survivor区的使用大小(KB)

S1U：第二个Survivor区的使用大小(KB)

EC：Eden区的大小(KB)

EU：Eden区的使用大小(KB)

OC：Old区大小(KB)

OU：Old使用大小(KB)

MC：方法区大小(KB)

MU：方法区使用大小(KB)

CCSC：压缩类空间大小(KB)

CCSU：压缩类空间使用大小(KB)

YGC：年轻代垃圾回收次数

YGCT：年轻代垃圾回收消耗时间

FGC：老年代垃圾回收次数

FGCT：老年代垃圾回收消耗时间

GCT：垃圾回收消耗总时间

2.使用jmap对内存进行分析

2.1查看堆内存情况

2.2查看内存中对象数量及大小

查看所有对象，包括活跃以及非活跃的

jmap ‐histo | more

只查看活跃的对象

jmap ‐histo:live | more

对象说明

B byte

C char

D double

F float

I int

J long

Z boolean

[ 数组，如[I表示int[]

[L+类名 其他对象

2.3将内存使用情况dump到文件中

jmap ‐dump:format=b,file=dumpFileName

2.4通过jhat对dump文件进行分析

一个未被占用的端口就行了

jhat ‐port

启动成功如下图

使用浏览器访问本机的9999(自己设置的)端口

网页中显示的就是所有的对象,直接拉到最下面可以使用OQL进行查询

OQL语法类似于SQL语句,如果不会使用可以查看帮助

查询字符串长度大于等于1000的对象

select s from java.lang.String s where s.value.length>=1000

这样对dump文件进行分析的结果还是有些不太清晰,接下来

3.使用MAT工具对dump文件进行分析

工具下载地址 下载和自己jdk对应位数的

下载完成,解压并打开

4.内存泄漏定位与分析

编写导致内存泄漏的代码,启动时修改内存大小

importjava.util.ArrayList;importjava.util.List;importjava.util.UUID;public classTestJvmOutOfMemory {public static voidmain(String[] args) {

List list = new ArrayList<>();for (int i = 0; i < 10000000; i++) {

String str= "";for (int j = 0; j < 1000; j++) {

str+=UUID.randomUUID().toString();

}

list.add(str);

}

System.out.println("ok");

}

}

JVM参数如下

-Xms8m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

执行一段时间程序停止运行,抛出异常,并在项目的根目录下生成一个文件

接下来使用MAT工具分析上面的文件

由上图可见,占用了总内存的90%导致了内存不足程序的退出,这种情况下不适合修改JVM参数,应当找到导致问题所在的代码,进行调整

点击上图中的Details可以看见每个对象占用的多大内存

5.使用jstack监控死锁问题

jstack

先来了解一下线程的状态

初始态(NEW)

创建一个Thread对象，但还未调用start()启动线程时，线程处于初始态。

运行态(RUNNABLE)，在Java中，运行态包括 就绪态 和 运行态。

就绪态

该状态下的线程已经获得执行所需的所有资源，只要CPU分配执行权就能运 行。

所有就绪态的线程存放在就绪队列中。

运行态

获得CPU执行权，正在执行的线程。

由于一个CPU同一时刻只能执行一条线程，因此每个CPU每个时刻只有一条 运行态的线程。

阻塞态(BLOCKED)

当一条正在执行的线程请求某一资源失败时，就会进入阻塞态。

而在Java中，阻塞态专指请求锁失败时进入的状态。

由一个阻塞队列存放所有阻塞态的线程。

处于阻塞态的线程会不断请求资源，一旦请求成功，就会进入就绪队列，等待执 行。

等待态(WAITING)

当前线程中调用wait、join、park函数时，当前线程就会进入等待态。

也有一个等待队列存放所有等待态的线程。

线程处于等待态表示它需要等待其他线程的指示才能继续运行。

进入等待态的线程会释放CPU执行权，并释放资源(如：锁)

超时等待态(TIMED_WAITING)

当运行中的线程调用sleep(time)、wait、join、parkNanos、parkUntil时，就 会进入该状态；

它和等待态一样，并不是因为请求不到资源，而是主动进入，并且进入后需要其 他线程唤醒；

进入该状态后释放CPU执行权 和 占有的资源。

与等待态的区别：到了超时时间后自动进入阻塞队列，开始竞争锁。

终止态(TERMINATED)

线程执行结束后的状态。

模拟死锁的代码

public classTestDeadLock {private static Object obj1 = newObject();private static Object obj2 = newObject();public static voidmain(String[] args) {new Thread(newThread1()).start();new Thread(newThread2()).start();

}private static class Thread1 implementsRunnable {

@Overridepublic voidrun() {synchronized(obj1) {

System.out.println("Thread1 拿到了 obj1 的锁！");try{//停顿2秒的意义在于，让Thread2线程拿到obj2的锁

Thread.sleep(2000);

}catch(InterruptedException e) {

e.printStackTrace();

}synchronized(obj2) {

System.out.println("Thread1 拿到了 obj2 的锁！");

}

}

}

}private static class Thread2 implementsRunnable {

@Overridepublic voidrun() {synchronized(obj2) {

System.out.println("Thread2 拿到了 obj2 的锁！");try{//停顿2秒的意义在于，让Thread1线程拿到obj1的锁

Thread.sleep(2000);

}catch(InterruptedException e) {

e.printStackTrace();

}synchronized(obj1) {

System.out.println("Thread2 拿到了 obj1 的锁！");

}

}

}

}

}

使用jstack加上进程号进行查看