Java内存溢出紧急处理:10个必知的Linux命令快速定位OOM

文彬编程网编码文章Java内存溢出紧急处理:10个必知的Linux命令快速定位OOM

Java内存溢出紧急处理:10个必知的Linux命令快速定位OOM

编码文章call10242025-06-20 14:31:264A⁺A^-

引言

在Java应用程序的运维过程中，内存溢出(OutOfMemoryError，简称OOM)是最常见也是最棘手的问题之一。当Java应用程序耗尽了所有可用内存时，不仅会导致服务不可用，还可能引发级联故障。本文将详细介绍在Linux环境下，如何利用10个核心命令快速定位和解决Java内存溢出问题，帮助运维人员和开发人员在紧急情况下迅速恢复服务并根治问题。

Java内存溢出的常见类型与症状

在深入了解Linux命令之前，我们需要先了解Java内存溢出的常见类型及其症状，以便能够快速识别问题：

Heap Space OOM

症状：OutOfMemoryError: Java heap space
原因：应用程序创建了过多的对象，超出了堆内存的容量
影响：应用程序无法继续创建新对象，导致服务不可用

PermGen/Metaspace OOM

症状：OutOfMemoryError: PermGen space 或 OutOfMemoryError: Metaspace
原因：类加载器加载了过多的类定义，超出了永久代/元空间的容量
影响：无法加载新的类定义，导致应用程序崩溃

Direct Buffer Memory OOM

症状：OutOfMemoryError: Direct buffer memory
原因：应用程序使用NIO的DirectByteBuffer分配了过多的直接内存
影响：系统无法分配更多的直接内存，导致IO操作失败

GC Overhead Limit Exceeded

症状：OutOfMemoryError: GC overhead limit exceeded
原因：垃圾回收器花费了过多的时间进行垃圾回收，而实际处理业务的时间不足
影响：应用程序响应缓慢，甚至无法正常工作

StackOverflowError

症状：StackOverflowError
原因：方法调用栈过深，超出了线程栈的容量
影响：特定方法无法正常执行，可能导致应用程序部分功能失效

Linux命令一：top - 监控系统资源

top命令简介

top命令是Linux系统中最常用的资源监控工具之一，它可以实时显示系统中各个进程的资源使用情况，包括CPU、内存、IO等。在处理Java内存溢出问题时，top命令可以帮助我们快速定位占用大量资源的Java进程。

top命令的常用参数

-p <pid>：只显示指定进程ID的信息
-H：显示线程信息而非进程信息
-d <秒数>：指定刷新间隔时间
-c：显示完整的命令行信息

使用top命令监控Java进程

当发现系统出现Java内存溢出问题时，首先可以使用top命令查看系统中占用内存最多的进程：

top

在top命令的输出中，按M键可以按照内存使用量排序，找到占用内存最多的Java进程ID。然后使用-p参数只显示该Java进程的信息：

top -p <pid>

为了进一步分析Java进程内部的线程资源使用情况，可以使用-H参数：

top -pH <pid>

这将显示Java进程中各个线程的资源使用情况，帮助我们找出可能导致内存溢出的线程。

实际案例分析

假设我们发现一个Java应用程序出现了内存溢出问题，首先使用top命令找到该Java进程：

top

输出结果中，我们看到一个名为java -jar app.jar的进程占用了90%的系统内存，进程ID为12345。接下来，我们使用-p参数只显示该进程的信息：

top -p 12345

然后按H键查看该进程内部的线程信息，发现线程ID为12350的线程占用了大量的CPU资源。这可能是一个处理大量数据的线程，需要进一步分析。

Linux命令二：ps - 查看进程详细信息

ps命令简介

ps命令用于显示当前系统中进程的详细信息，包括进程ID、父进程ID、CPU使用率、内存使用率、启动时间等。在处理Java内存溢出问题时，ps命令可以帮助我们获取Java进程的详细信息，为后续分析提供依据。

ps命令的常用参数

-ef：显示所有进程的详细信息
-aux：显示所有进程的资源使用情况
-p <pid>：只显示指定进程ID的信息
--sort：按照指定字段排序，如--sort=-rss按内存使用量降序排序

使用ps命令获取Java进程信息

当使用top命令找到占用大量内存的Java进程后，可以使用ps命令获取该进程的详细信息：

ps -ef | grep java

这将显示所有Java进程的详细信息，包括启动命令、启动时间、所属用户等。如果已经知道Java进程的ID，可以使用-p参数只显示该进程的信息：

ps -p <pid> -o pid,ppid,user,%cpu,%mem,vsz,rss,tty,stat,start,time,command

其中，vsz表示进程虚拟内存大小，rss表示进程实际使用的物理内存大小。

使用ps命令监控Java进程内存变化

为了监控Java进程的内存使用情况随时间的变化，可以使用watch命令定期执行ps命令：

watch -n 5 "ps -p <pid> -o pid,%cpu,%mem,vsz,rss,command"

这将每5秒更新一次Java进程的资源使用情况，帮助我们观察内存使用量是否持续增长。

实际案例分析

继续上面的案例，我们使用ps命令获取Java进程12345的详细信息：

ps -p 12345 -o pid,ppid,user,%cpu,%mem,vsz,rss,tty,stat,start,time,command

输出结果显示：

  PID  PPID USER     %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
12345 12344 root      10  85 2147483647 8589934592 ?     Ssl  10:00   5:20 java -jar app.jar -Xmx8g -Xms8g

从输出中我们可以看到，该Java进程的虚拟内存大小(VSZ)为2147483647KB，实际使用的物理内存大小(RSS)为8589934592KB，约8GB，这与JVM参数-Xmx8g设置的最大堆内存大小一致。

Linux命令三：jps - 查找Java进程

jps命令简介

jps(Java Virtual Machine Process Status Tool)是JDK自带的一个工具，用于列出当前系统中所有运行的Java进程及其基本信息。在处理Java内存溢出问题时，jps命令可以帮助我们快速定位Java进程的ID。

jps命令的常用参数

-l：显示完整的包名和类名
-v：显示传递给JVM的参数
-m：显示传递给main方法的参数
-q：只显示进程ID

使用jps命令查找Java进程

在Linux系统中，使用jps命令可以快速列出所有运行的Java进程：

jps -lvm

这将显示Java进程的ID、完整的包名和类名、传递给JVM的参数以及传递给main方法的参数。

使用jps命令与其他命令结合

jps命令通常与其他Java诊断工具结合使用，例如：

# 获取Java进程ID并传递给jstat命令
jps -q | xargs -I {} jstat -gc {} 1000 10

这将每1000毫秒(1秒)显示一次所有Java进程的GC统计信息，共显示10次。

实际案例分析

假设我们需要找出运行在系统中的所有Java进程，可以使用以下命令：

jps -lvm

输出结果可能如下：

12345 com.example.App -Xmx8g -Xms8g -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp
12367 org.apache.catalina.startup.Bootstrap -Xmx2g -Xms2g
12389 sun.tools.jps.Jps -Dapplication.home=/usr/lib/jvm/java-11-openjdk-amd64 -Xms8m

从输出中我们可以看到，进程ID为12345的Java进程是我们的应用程序，它设置了最大堆内存为8GB，并且启用了OOM时自动生成堆转储文件的功能。

Linux命令四：jstat - 监控JVM统计信息

jstat命令简介

jstat(Java Virtual Machine Statistics Monitoring Tool)是JDK自带的一个工具，用于监控JVM的各种统计信息，包括类加载、内存使用、垃圾回收等。在处理Java内存溢出问题时，jstat命令可以帮助我们实时监控JVM的内存使用情况和垃圾回收行为。

jstat命令的常用参数

-gc：显示垃圾回收统计信息
-gccapacity：显示各代内存区域的容量
-gcutil：显示垃圾回收统计信息和内存使用百分比
-class：显示类加载统计信息
-compiler：显示JIT编译器统计信息
<pid>：Java进程ID
<interval>：统计信息刷新间隔(毫秒)
<count>：统计信息刷新次数

使用jstat命令监控GC统计信息

为了监控Java进程的垃圾回收情况，可以使用以下命令：

jstat -gc <pid> <interval> <count>

例如，每1000毫秒(1秒)显示一次Java进程12345的GC统计信息，共显示10次：

jstat -gc 12345 1000 10

输出结果中的关键指标包括：

S0C、S1C：Survivor区0和1的容量(KB)
S0U、S1U：Survivor区0和1的使用量(KB)
EC：Eden区的容量(KB)
EU：Eden区的使用量(KB)
OC：老年代的容量(KB)
OU：老年代的使用量(KB)
MC：元空间的容量(KB)
MU：元空间的使用量(KB)
YGC：新生代垃圾回收次数
YGCT：新生代垃圾回收总耗时(秒)
FGC：Full GC次数
FGCT：Full GC总耗时(秒)
GCT：垃圾回收总耗时(秒)

使用jstat命令监控内存使用百分比

为了更直观地了解JVM各代内存区域的使用情况，可以使用-gcutil参数：

jstat -gcutil <pid> <interval> <count>

例如：

jstat -gcutil 12345 1000 10

输出结果中的关键指标包括：

S0、S1：Survivor区0和1的使用百分比
E：Eden区的使用百分比
O：老年代的使用百分比
M：元空间的使用百分比
CCS：压缩类空间的使用百分比
YGC、YGCT、FGC、FGCT、GCT：同-gc参数的输出

实际案例分析

假设我们需要监控Java进程12345的垃圾回收情况，使用以下命令：

jstat -gcutil 12345 1000 10

输出结果如下：

  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT   
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45
  0.00   0.00  99.99  99.98  99.97  99.96  1234   56.78   123   45.67   102.45

从输出中我们可以看到，Eden区、老年代和元空间的使用百分比都接近100%，这表明Java进程的内存使用已经非常紧张，可能即将发生内存溢出。同时，YGC和FGC的次数较多，说明垃圾回收器一直在努力回收内存，但效果不佳。

Linux命令五：jmap - 生成堆转储文件

jmap命令简介

jmap(Java Memory Map)是JDK自带的一个工具，用于生成Java进程的堆转储文件(Heap Dump)，以及查看堆内存使用情况。在处理Java内存溢出问题时，jmap命令可以帮助我们获取Java堆的快照，以便后续使用工具进行分析。

jmap命令的常用参数

-dump:format=b,file=<filename>：生成二进制格式的堆转储文件
-heap：显示Java堆的详细信息
-histo[:live]：显示堆中对象的统计信息，live参数只统计存活的对象
-permstat：显示永久代/元空间的类加载器统计信息

使用jmap命令生成堆转储文件

为了生成Java进程的堆转储文件，可以使用以下命令：

jmap -dump:format=b,file=/tmp/heapdump.hprof <pid>

例如，为Java进程12345生成堆转储文件：

jmap -dump:format=b,file=/tmp/heapdump.hprof 12345

这将在/tmp目录下生成一个名为heapdump.hprof的堆转储文件。生成堆转储文件可能需要一些时间，具体取决于Java堆的大小。

使用jmap命令查看堆内存使用情况

为了查看Java进程的堆内存使用情况，可以使用以下命令：

jmap -heap <pid>

例如：

jmap -heap 12345

输出结果中的关键信息包括：

JVM的堆内存配置信息
各代内存区域的使用情况
GC策略信息

使用jmap命令查看堆中对象的统计信息

为了查看堆中对象的统计信息，可以使用以下命令：

jmap -histo[:live] <pid> | head -20

例如：

jmap -histo:live 12345 | head -20

这将显示堆中数量最多的20种对象类型及其数量和占用内存大小。

实际案例分析

假设我们需要为Java进程12345生成堆转储文件，使用以下命令：

jmap -dump:format=b,file=/tmp/heapdump.hprof 12345

命令执行后，输出结果如下：

Dumping heap to /tmp/heapdump.hprof ...
Heap dump file created [8589934592 bytes in 120.456 secs]

这表明堆转储文件已成功生成，文件大小为8GB，生成过程耗时120.456秒。

接下来，我们查看Java进程12345的堆内存使用情况：

jmap -heap 12345

输出结果中的关键部分如下：

Attaching to process ID 12345, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 11.0.11+9-Ubuntu-0ubuntu2.20.04

using parallel threads in the new generation.
using thread-local object allocation.
Concurrent Mark-Sweep GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 8589934592 (8192.0MB)
   NewSize                  = 17825792 (17.0MB)
   MaxNewSize               = 2863671296 (2731.0MB)
   OldSize                  = 35752960 (34.1MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044416MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
New Generation (Eden + 1 Survivor Space):
   capacity = 2794297344 (2664.875MB)
   used     = 2793981928 (2664.5113830566406MB)
   free     = 315416 (0.363616943359375MB)
   99.99% used
Eden Space:
   capacity = 2483819520 (2368.75MB)
   used     = 2483504088 (2368.411407470703MB)
   free     = 315432 (0.338592529296875MB)
   99.98% used
From Space:
   capacity = 310477824 (296.125MB)
   used     = 310477840 (296.12501525878906MB)
   free     = -16 (0.0MB)
   100.0% used
To Space:
   capacity = 310477824 (296.125MB)
   used     = 0 (0.0MB)
   free     = 310477824 (296.125MB)
   0.0% used
tenured generation:
   capacity = 5795637248 (5527.125MB)
   used     = 5795321880 (5526.812080383301MB)
   free     = 315368 (0.31291961669921875MB)
   99.99% used

32244 interned Strings occupying 3154168 bytes.

从输出中我们可以看到，Eden区和老年代的使用百分比都接近100%，这与jstat命令的输出结果一致。同时，我们还可以看到JVM的堆内存配置信息和GC策略信息。

Linux命令六：jhat - 分析堆转储文件

jhat命令简介

jhat(Java Heap Analysis Tool)是JDK自带的一个工具，用于分析Java堆转储文件。它会启动一个HTTP服务器，提供一个简单的Web界面来浏览堆转储文件中的对象信息。在处理Java内存溢出问题时，jhat命令可以帮助我们初步分析堆转储文件，找出可能导致内存溢出的对象。

jhat命令的常用参数

-port <port>：指定HTTP服务器的端口号
-stack false：不显示对象的堆栈信息，减少内存使用
-refs false：不显示对象的引用信息，减少内存使用
-baseline <file>：指定基准堆转储文件，用于比较
-debug <level>：设置调试级别

使用jhat命令分析堆转储文件

为了分析Java进程的堆转储文件，可以使用以下命令：

jhat -port 7000 /tmp/heapdump.hprof

这将启动一个HTTP服务器，监听7000端口，并加载堆转储文件进行分析。命令执行后，会输出一些信息，包括分析进度和HTTP服务器的URL：

Reading from /tmp/heapdump.hprof...
Dump file created Thu Jan 01 00:00:00 UTC 1970
Snapshot read, resolving...
Resolving 8589934592 objects...
Chasing references, expect 1717986918 dots...
Eliminating duplicate references...
Snapshot resolved.
Started HTTP server on port 7000
Server is ready.

然后，我们可以在浏览器中访问http://localhost:7000来查看堆转储文件的分析结果。

jhat分析界面的主要功能

jhat提供的Web界面包含以下主要功能：

All Classes (excluding platform)：显示所有非平台类的列表
All Classes (including platform)：显示所有类的列表
Index Pages：提供各种索引页面，如类索引、包索引等
Show Heap Histogram：显示堆中对象的统计信息
Show Finalizer Summary：显示等待终结的对象信息
Execute Object Query Language (OQL) Query：执行OQL查询
Show System Properties：显示系统属性

实际案例分析

假设我们已经使用jmap命令为Java进程12345生成了堆转储文件/tmp/heapdump.hprof，现在使用jhat命令进行分析：

jhat -port 7000 /tmp/heapdump.hprof

命令执行完成后，我们在浏览器中访问http://localhost:7000，首先查看堆中对象的统计信息：

Show Heap Histogram

这将显示堆中各种类型对象的数量和占用内存大小。从结果中，我们发现以下几种对象占用了大量内存：

num     #instances         #bytes  class name
-------------------------------------------------------
   1:       1000000     1048576000  [B (byte[])
   2:        500000      524288000  java.util.HashMap$Node
   3:        200000      409600000  java.lang.String
   4:        100000      327680000  [Ljava.lang.Object; (Object[])
   5:         50000      262144000  java.util.ArrayList

从这些结果中，我们可以初步判断byte数组、HashMap节点和String对象占用了大量内存，可能是导致内存溢出的原因。

接下来，我们可以进一步分析这些对象的引用关系和创建位置，以便找出问题的根源。

Linux命令七：jstack - 生成线程快照

jstack命令简介

jstack(Java Stack Trace)是JDK自带的一个工具，用于生成Java进程的线程快照(Thread Dump)。线程快照包含了每个线程的当前执行状态和调用栈信息，在处理Java内存溢出问题时，jstack命令可以帮助我们找出可能导致内存泄漏的线程和方法。

jstack命令的常用参数

-l：显示锁的详细信息
-F：当正常输出的请求不被响应时，强制输出线程堆栈
-m：如果调用到本地方法，可以显示C/C++的堆栈

使用jstack命令生成线程快照

为了生成Java进程的线程快照，可以使用以下命令：

jstack -l <pid> > /tmp/threaddump.txt

例如，为Java进程12345生成线程快照：

jstack -l 12345 > /tmp/threaddump.txt

这将把线程快照输出到/tmp/threaddump.txt文件中。

分析线程快照的关键信息

线程快照中包含以下关键信息：

线程状态：每个线程都有一个状态，如RUNNABLE、BLOCKED、WAITING、TIMED_WAITING等
调用栈：线程当前执行的方法调用栈
锁信息：线程持有的锁和等待的锁
线程ID：Java线程ID和操作系统线程ID

实际案例分析

假设我们需要为Java进程12345生成线程快照，使用以下命令：

jstack -l 12345 > /tmp/threaddump.txt

生成的线程快照文件中，我们可以看到以下关键信息：

"main" #1 prio=5 os_prio=0 tid=0x00007f9d00000000 nid=0x3e8 runnable [0x00007f9d088f9000]
   java.lang.Thread.State: RUNNABLE
        at java.io.FileInputStream.readBytes(Native Method)
        at java.io.FileInputStream.read(FileInputStream.java:255)
        at java.io.BufferedInputStream.read1(BufferedInputStream.java:284)
        at java.io.BufferedInputStream.read(BufferedInputStream.java:345)
        at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
        at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
        at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
        at java.io.InputStreamReader.read(InputStreamReader.java:184)
        at java.io.BufferedReader.fill(BufferedReader.java:161)
        at java.io.BufferedReader.readLine(BufferedReader.java:324)
        at java.io.BufferedReader.readLine(BufferedReader.java:389)
        at com.example.App.readLargeFile(App.java:56)
        at com.example.App.processData(App.java:34)
        at com.example.App.main(App.java:18)

   Locked ownable synchronizers:
        - None

"GC task thread#0 (ParallelGC)" #2 prio=5 os_prio=0 tid=0x00007f9d00001000 nid=0x3e9 runnable

"GC task thread#1 (ParallelGC)" #3 prio=5 os_prio=0 tid=0x00007f9d00002000 nid=0x3ea runnable

"GC task thread#2 (ParallelGC)" #4 prio=5 os_prio=0 tid=0x00007f9d00003000 nid=0x3eb runnable

"GC task thread#3 (ParallelGC)" #5 prio=5 os_prio=0 tid=0x00007f9d00004000 nid=0x3ec runnable

"Service Thread" #16 prio=9 os_prio=0 tid=0x00007f9d00010000 nid=0x3f5 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"VM Thread" os_prio=0 tid=0x00007f9d0000c000 nid=0x3f1 runnable

"VM Periodic Task Thread" os_prio=0 tid=0x00007f9d00011000 nid=0x3f6 waiting on condition

JNI global references: 1024

从线程快照中，我们可以看到主线程正在执行
com.example.App.readLargeFile方法，该方法正在读取一个大文件。这可能是导致内存溢出的原因，因为该方法可能一次性将整个文件加载到内存中，而没有进行适当的分块处理。

此外，我们还可以看到有多个GC线程正在运行，这表明垃圾回收器正在努力回收内存。

Linux命令八：free - 监控系统内存

free命令简介

free命令用于显示系统内存的使用情况，包括物理内存、交换空间和缓存。在处理Java内存溢出问题时，free命令可以帮助我们了解系统整体的内存使用情况，判断内存溢出是由于Java应用程序本身的问题还是系统内存不足导致的。

free命令的常用参数

-h：以人类可读的格式显示内存大小
-m：以MB为单位显示内存大小
-g：以GB为单位显示内存大小
-s <秒数>：定期刷新内存信息
-t：显示内存使用的总和

使用free命令监控系统内存

为了查看系统内存的使用情况，可以使用以下命令：

free -h

这将以人类可读的格式显示系统内存的使用情况。输出结果中的关键指标包括：

total：总内存大小
used：已使用的内存大小
free：空闲的内存大小
shared：多个进程共享的内存大小
buff/cache：用于缓存的内存大小
available：可用的内存大小(包括空闲内存和可回收的缓存)

使用free命令定期监控系统内存

为了监控系统内存使用情况随时间的变化，可以使用以下命令：

free -hts 5

这将每5秒刷新一次系统内存信息，并显示内存使用的总和。

实际案例分析

假设我们需要查看系统内存的使用情况，使用以下命令：

free -h

输出结果如下：

              total        used        free      shared  buff/cache   available
Mem:            15G         12G        1.0G        128M        2.0G        2.5G
Swap:           7.9G        2.0G        5.9G

从输出中我们可以看到，系统总内存为15GB，已使用12GB，空闲1.0GB，可用2.5GB。交换空间总大小为7.9GB，已使用2.0GB，空闲5.9GB。

这表明系统内存使用已经非常紧张，Java进程可能已经开始使用交换空间，这会导致性能严重下降。结合之前的分析，我们可以判断Java进程的内存溢出问题是由于应用程序本身的内存使用不当导致的，而不是系统内存不足。

Linux命令九：lsof - 查看打开的文件

lsof命令简介

lsof(List Open Files)是一个强大的工具，用于列出系统中所有打开的文件。在Linux系统中，一切皆文件，包括网络套接字、管道、设备文件等。在处理Java内存溢出问题时，lsof命令可以帮助我们找出Java进程打开的文件和网络连接，从而发现可能导致内存泄漏的资源。

lsof命令的常用参数

-p <pid>：只显示指定进程ID打开的文件
-u <username>：只显示指定用户打开的文件
-i：显示网络连接
-i <协议>:<端口>：显示指定协议和端口的网络连接
-n：不解析主机名，提高性能
-P：不解析端口号，提高性能

使用lsof命令查看Java进程打开的文件

为了查看Java进程打开的文件，可以使用以下命令：

lsof -p <pid>

例如，查看Java进程12345打开的文件：

lsof -p 12345

这将显示Java进程12345打开的所有文件，包括标准输入/输出/错误流、日志文件、配置文件等。

使用lsof命令查看Java进程的网络连接

为了查看Java进程的网络连接，可以使用以下命令：

lsof -p <pid> -i

例如：

lsof -p 12345 -i

这将显示Java进程12345的所有网络连接，包括TCP连接、UDP连接等。

实际案例分析

假设我们需要查看Java进程12345打开的文件和网络连接，使用以下命令：

lsof -p 12345

输出结果中的关键部分如下：

COMMAND   PID USER   FD   TYPE             DEVICE SIZE/OFF    NODE NAME
java    12345 root  cwd    DIR              8,1     4096  204800 /app
java    12345 root  rtd    DIR              8,1     4096        2 /
java    12345 root  txt    REG              8,1 17422464 204801 /usr/lib/jvm/java-11-openjdk-amd64/bin/java
java    12345 root  mem    REG              8,1  2071368 204802 /usr/lib/jvm/java-11-openjdk-amd64/lib/server/libjvm.so
java    12345 root  mem    REG              8,1   408800 204803 /usr/lib/jvm/java-11-openjdk-amd64/lib/libnet.so
java    12345 root  mem    REG              8,1   104640 204804 /usr/lib/jvm/java-11-openjdk-amd64/lib/libnio.so
java    12345 root    0u   CHR              1,3      0t0    1066 /dev/null
java    12345 root    1u   CHR              1,3      0t0    1066 /dev/null
java    12345 root    2u   CHR              1,3      0t0    1066 /dev/null
java    12345 root    3r   REG              8,1 8589934592 204805 /tmp/heapdump.hprof
java    12345 root    4u  IPv4          1234567      0t0    TCP *:8080 (LISTEN)
java    12345 root    5u  IPv4          1234568      0t0    TCP localhost:8080->localhost:43210 (ESTABLISHED)
java    12345 root    6u  IPv4          1234569      0t0    TCP localhost:8080->localhost:43212 (ESTABLISHED)
java    12345 root    7u  IPv4          1234570      0t0    TCP localhost:8080->localhost:43214 (ESTABLISHED)
java    12345 root    8u  IPv4          1234571      0t0    UDP localhost:5353

从输出中我们可以看到，Java进程12345打开了一个8GB的堆转储文件/tmp/heapdump.hprof，这与我们之前使用jmap命令生成的堆转储文件一致。此外，Java进程还在监听8080端口，并建立了多个TCP连接。

接下来，我们查看Java进程12345的网络连接：

lsof -p 12345 -i

输出结果如下：

COMMAND   PID USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
java    12345 root    4u  IPv4          1234567      0t0  TCP *:8080 (LISTEN)
java    12345 root    5u  IPv4          1234568      0t0  TCP localhost:8080->localhost:43210 (ESTABLISHED)
java    12345 root    6u  IPv4          1234569      0t0  TCP localhost:8080->localhost:43212 (ESTABLISHED)
java    12345 root    7u  IPv4          1234570      0t0  TCP localhost:8080->localhost:43214 (ESTABLISHED)
java    12345 root    8u  IPv4          1234571      0t0  UDP localhost:5353

这与我们之前的输出一致，确认了Java进程12345的网络连接情况。

Linux命令十：netstat - 监控网络连接

netstat命令简介

netstat(Network Statistics)是一个用于显示网络连接、路由表和网络接口统计信息的工具。在处理Java内存溢出问题时，netstat命令可以帮助我们监控Java进程的网络连接情况，找出可能导致内存泄漏的网络资源。

netstat命令的常用参数

-t：显示TCP连接
-u：显示UDP连接
-n：不解析主机名和端口号，提高性能
-l：只显示监听状态的连接
-p：显示进程ID和名称
-a：显示所有连接(包括监听和非监听状态)
-s：显示网络统计信息

使用netstat命令查看Java进程的网络连接

为了查看Java进程的网络连接，可以使用以下命令：

netstat -tunlp | grep <pid>

例如，查看Java进程12345的网络连接：

netstat -tunlp | grep 12345

这将显示Java进程12345的所有TCP和UDP连接。

使用netstat命令监控网络连接的变化

为了监控网络连接随时间的变化，可以使用watch命令定期执行netstat命令：

watch -n 5 "netstat -tunlp | grep <pid>"

这将每5秒更新一次Java进程的网络连接信息。

实际案例分析

假设我们需要查看Java进程12345的网络连接，使用以下命令：

netstat -tunlp | grep 12345

输出结果如下：

tcp        0      0 0.0.0.0:8080            0.0.0.0:*               LISTEN      12345/java           
tcp        0      0 127.0.0.1:8080          127.0.0.1:43210         ESTABLISHED 12345/java           
tcp        0      0 127.0.0.1:8080          127.0.0.1:43212         ESTABLISHED 12345/java           
tcp        0      0 127.0.0.1:8080          127.0.0.1:43214         ESTABLISHED 12345/java           
udp        0      0 127.0.0.1:5353          0.0.0.0:*                           12345/java

从输出中我们可以看到，Java进程12345正在监听8080端口，并建立了多个TCP连接。这与我们之前使用lsof命令的输出结果一致。

接下来，我们使用watch命令监控Java进程12345的网络连接变化：

watch -n 5 "netstat -tunlp | grep 12345"

通过观察网络连接的变化，我们可以发现是否有异常的连接建立或断开，从而找出可能导致内存泄漏的网络资源。

综合案例分析：解决一个实际的Java内存溢出问题

为了更好地理解如何使用上述Linux命令解决Java内存溢出问题，下面我们通过一个实际案例来演示整个分析和解决过程。

案例背景

某公司的一个Java Web应用程序在高并发情况下频繁出现内存溢出问题，导致服务不可用。该应用程序运行在Linux服务器上，使用Tomcat作为Web容器，JDK版本为11。

问题复现

启动应用程序，使用JMeter进行高并发测试
当并发用户数达到1000时，应用程序开始出现响应缓慢
当并发用户数达到1500时，应用程序抛出OutOfMemoryError异常，服务不可用

问题分析过程

第一步：使用top命令定位问题进程

top

按M键按照内存使用量排序，发现Tomcat进程(Java进程)占用了90%的系统内存，进程ID为12345。

第二步：使用ps命令获取进程详细信息

ps -p 12345 -o pid,ppid,user,%cpu,%mem,vsz,rss,tty,stat,start,time,command

输出结果显示该Java进程的JVM参数设置为：-Xmx4g -Xms4g，即最大堆内存为4GB。

第三步：使用jstat命令监控JVM内存使用情况

jstat -gcutil 12345 1000 10

输出结果显示Eden区和老年代的使用百分比都接近100%，且Full GC次数频繁，说明垃圾回收器一直在努力回收内存，但效果不佳。

第四步：使用jmap命令生成堆转储文件

jmap -dump:format=b,file=/tmp/heapdump.hprof 12345

生成的堆转储文件大小为4GB，说明Java堆已经被完全填满。

第五步：使用jhat命令分析堆转储文件

jhat -port 7000 /tmp/heapdump.hprof

在浏览器中访问http://localhost:7000，查看堆中对象的统计信息，发现大量的java.util.HashMap$Node和java.lang.String对象占用了大部分内存。进一步分析这些对象的引用关系，发现它们都是由一个缓存模块创建的。

第六步：使用jstack命令生成线程快照

jstack -l 12345 > /tmp/threaddump.txt

分析线程快照，发现有多个线程在执行缓存模块的方法，且这些线程都处于RUNNABLE状态，说明缓存模块正在被频繁访问。

第七步：使用free命令查看系统内存使用情况

free -h

输出结果显示系统内存使用已经非常紧张，可用内存不足1GB。

第八步：使用lsof命令查看Java进程打开的文件

lsof -p 12345

输出结果显示Java进程打开了大量的文件句柄，这些文件句柄都是由缓存模块创建的。

问题原因

通过以上分析，我们发现内存溢出的根本原因是缓存模块设计不合理：

缓存模块使用了一个全局的HashMap来存储数据，且没有设置缓存大小限制和过期策略
在高并发情况下，缓存中的数据不断增加，最终导致堆内存溢出
缓存模块还打开了大量的文件句柄，但没有及时关闭，导致资源泄漏

解决方案

修改缓存模块，使用Guava Cache或Caffeine等成熟的缓存框架，设置合理的缓存大小和过期策略

// 使用Guava Cache替代原来的HashMap
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

public class CacheService {
    private static final Cache<String, Object> cache = CacheBuilder.newBuilder()
            .maximumSize(10000) // 设置最大缓存条目数
            .expireAfterWrite(30, TimeUnit.MINUTES) // 设置过期时间
            .build();
    
    public static void put(String key, Object value) {
        cache.put(key, value);
    }
    
    public static Object get(String key) {
        return cache.getIfPresent(key);
    }
    
    public static void remove(String key) {
        cache.invalidate(key);
    }
    
    public static void clear() {
        cache.invalidateAll();
    }
}

优化缓存模块的文件操作，确保文件句柄在使用完毕后及时关闭

// 优化文件操作，确保资源释放
public class FileService {
    public static void processFile(String filePath) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 处理文件内容
            }
        } catch (IOException e) {
            // 异常处理
        }
    }
}

调整JVM参数，增加堆内存大小，并启用GC日志

# 修改JVM参数
JAVA_OPTS="-Xmx6g -Xms6g -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:/tmp/gc.log"

验证结果

应用上述解决方案后，重新进行高并发测试：

当并发用户数达到2000时，应用程序仍然稳定运行
使用jstat命令监控JVM内存使用情况，发现内存使用趋于稳定，不再持续增长
使用jmap命令生成堆转储文件，文件大小明显减小，只有几百MB
使用free命令查看系统内存使用情况，发现系统内存使用也趋于稳定

通过这些验证，我们确认内存溢出问题已经得到解决。

总结

Java内存溢出是Java应用程序开发和运维过程中常见的问题，本文详细介绍了在Linux环境下使用10个核心命令快速定位和解决Java内存溢出问题的方法：

top：监控系统资源，定位占用大量内存的Java进程
ps：查看进程详细信息，获取Java进程的JVM参数
jps：查找Java进程，获取Java进程的ID
jstat：监控JVM统计信息，实时查看内存使用情况和垃圾回收行为
jmap：生成堆转储文件，获取Java堆的快照
jhat：分析堆转储文件，找出可能导致内存溢出的对象
jstack：生成线程快照，找出可能导致内存泄漏的线程和方法
free：监控系统内存，了解系统整体的内存使用情况
lsof：查看打开的文件，找出Java进程打开的文件和网络连接
netstat：监控网络连接，找出可能导致内存泄漏的网络资源

通过综合使用这些命令，我们可以快速定位Java内存溢出的原因，并采取相应的措施进行解决。

点击这里复制本文地址以上内容由文彬编程网整理呈现，请务必在转载分享时注明本文地址！如对内容有疑问，请联系我们，谢谢！

java命令

上一篇：Java字节码指令:if_icmpgt(0xA3)

下一篇：Java 命令行参数解析方式探索(四):Spark & Flink

Java内存溢出紧急处理:10个必知的Linux命令快速定位OOM

引言

Java内存溢出的常见类型与症状

Linux命令一：top - 监控系统资源

Linux命令二：ps - 查看进程详细信息

Linux命令三：jps - 查找Java进程

Linux命令四：jstat - 监控JVM统计信息

Linux命令五：jmap - 生成堆转储文件

Linux命令六：jhat - 分析堆转储文件

Linux命令七：jstack - 生成线程快照

Linux命令八：free - 监控系统内存

Linux命令九：lsof - 查看打开的文件

Linux命令十：netstat - 监控网络连接

综合案例分析：解决一个实际的Java内存溢出问题

总结

相关文章