记一次查内存异常问题(续《记一次Web应用CPU偏高》)

简介: 继上一次查应用的CPU飙高问题(http://www.cnblogs.com/hzmark/p/JVM_CPU.html)过去10天了。上次只是定位到了是一个第三方包占用了大量的CPU使用,但没有细致的去查第三方包为什么占用了这么高的CPU,并且内存为什么如此诡异。

继上一次查应用的CPU飙高问题(http://www.cnblogs.com/hzmark/p/JVM_CPU.html)过去10天了。上次只是定位到了是一个第三方包占用了大量的CPU使用,但没有细致的去查第三方包为什么占用了这么高的CPU,并且内存为什么如此诡异。总的来说上一次排查带来的收获是熟悉了JVM的工具使用和大致定位到了问题。

在上次排查问题之后,应用出现异常的频率还是较高,终下定决心再查一次,而这次排查的重点落在内存方面。因为怀疑CPU偏高是因为内存的异常导致频繁的GC引起的。

首先是JVM内存的状态:

S0和S1交替的用满,不停的在进行YGC。

使用jmap可以看到内存中那些对象使用了大量的内存:

下面是列出内存占用的方法(下图不是异常状态的时候的现象):

在异常状态的情况下看到的现象是class name:[B占用好几个G的内存,也就是byte数组占用了很大的内存。

结合上一次查CPU问题时定位到的问题代码:

仔细看出问题的线程:com.trilead.ssh2.StreamGobbler$GobblerThread.run

到这里为止都是通过上次排查CPU问题可以推测出来的,其实仔细一点耐心一点顺着com.trilead.ssh2.StreamGobbler$GobblerThread.run继续往下分析能定位到具体问题,但是到这里之后我才用了另一种方式去定位问题,那就是分析出现问题时的堆内存使用情况,下面是我的分析过程。

首先dump内存数据:

jmap -dump:format=b,file=xxx.bin 3230

其中xxx.bin是dump出来的文件,3230是pid

之后使用mat打开该文件(这边不介绍MAT的使用,可以自己查找帮助文档;我使用的是eclipse的mat插件,可以在官网上找到update的地址在线安装就可以了http://download.eclipse.org/mat/1.3.1/update-site/)

这是一个概览信息,可以看到总共使用了618M内存,而有一块直接占用了576M,那么问题肯定出现在这块内存中。

点到leak suspects会有一个系统分析的怀疑问题:

和上一步我们的猜想是一致的,问题出在最大的这个内存这里。和排查CPU时得出的结论也是一致的,问题出在第三方的包内。

点击detail内容可以看到具体是哪里占用了内存。

通过with outgoing references查看线程引用的对象,如下图所示:

在找到使用内存最大的对象,查找他的引用,可以看到代码中是哪里引用了这块内存导致无法被回收

到这里位置就可以知道是自己起的线程保持了对内存的引用导致无法别回收。查自己写的代码已经可以精确的定位到问题。
(其实根据上次使用到一些JVM的工具已经可以发现问题,但是问了跟精确,顺便学习内存排查,所以有了MAT分析的过程)

下面是定位到问题代码之后的处理。

查看具体的代码:

  1 package com.trilead.ssh2;
  2 
  3 import java.io.IOException;
  4 import java.io.InputStream;
  5 import java.io.InterruptedIOException;
  6 
  7 /**
  8  * A <code>StreamGobbler</code> is an InputStream that uses an internal worker
  9  * thread to constantly consume input from another InputStream. It uses a buffer
 10  * to store the consumed data. The buffer size is automatically adjusted, if needed.
 11  * <p>
 12  * This class is sometimes very convenient - if you wrap a session's STDOUT and STDERR
 13  * InputStreams with instances of this class, then you don't have to bother about
 14  * the shared window of STDOUT and STDERR in the low level SSH-2 protocol,
 15  * since all arriving data will be immediatelly consumed by the worker threads.
 16  * Also, as a side effect, the streams will be buffered (e.g., single byte
 17  * read() operations are faster).
 18  * <p>
 19  * Other SSH for Java libraries include this functionality by default in
 20  * their STDOUT and STDERR InputStream implementations, however, please be aware
 21  * that this approach has also a downside:
 22  * <p>
 23  * If you do not call the StreamGobbler's <code>read()</code> method often enough
 24  * and the peer is constantly sending huge amounts of data, then you will sooner or later
 25  * encounter a low memory situation due to the aggregated data (well, it also depends on the Java heap size).
 26  * Joe Average will like this class anyway - a paranoid programmer would never use such an approach.
 27  * <p>
 28  * The term "StreamGobbler" was taken from an article called "When Runtime.exec() won't",
 29  * see http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html.
 30  * 
 31  * @author Christian Plattner, plattner@trilead.com
 32  * @version $Id: StreamGobbler.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
 33  */
 34 
 35 public class StreamGobbler extends InputStream
 36 {
 37     class GobblerThread extends Thread
 38     {
 39         public void run()
 40         {
 41             byte[] buff = new byte[8192];
 42 
 43             while (true)
 44             {
 45                 try
 46                 {
 47                     int avail = is.read(buff);
 48 
 49                     synchronized (synchronizer)
 50                     {
 51                         if (avail <= 0)
 52                         {
 53                             isEOF = true;
 54                             synchronizer.notifyAll();
 55                             break;
 56                         }
 57                         
 58                         int space_available = buffer.length - write_pos;
 59                         
 60                         if (space_available < avail)
 61                         {
 62                             /* compact/resize buffer */
 63 
 64                             int unread_size = write_pos - read_pos;
 65                             int need_space = unread_size + avail;
 66 
 67                             byte[] new_buffer = buffer;
 68 
 69                             if (need_space > buffer.length)
 70                             {
 71                                 int inc = need_space / 3;
 72                                 inc = (inc < 256) ? 256 : inc;
 73                                 inc = (inc > 8192) ? 8192 : inc;
 74                                 new_buffer = new byte[need_space + inc];
 75                             }
 76                             
 77                             if (unread_size > 0)
 78                                 System.arraycopy(buffer, read_pos, new_buffer, 0, unread_size);
 79 
 80                             buffer = new_buffer;
 81                             
 82                             read_pos = 0;
 83                             write_pos = unread_size;
 84                         }
 85                         
 86                         System.arraycopy(buff, 0, buffer, write_pos, avail);
 87                         write_pos += avail;
 88 
 89                         synchronizer.notifyAll();
 90                     }    
 91                 }
 92                 catch (IOException e)
 93                 {
 94                     synchronized (synchronizer)
 95                     {
 96                         exception = e;
 97                         synchronizer.notifyAll();
 98                         break;
 99                     }
100                 }
101             }
102         }
103     }
104 
105     private InputStream is;
106     private final GobblerThread t;
107 
108     private final Object synchronizer = new Object();
109 
110     private boolean isEOF = false;
111     private boolean isClosed = false;
112     private IOException exception = null;
113 
114     private byte[] buffer = new byte[2048];
115     private int read_pos = 0;
116     private int write_pos = 0;
117 
118     public StreamGobbler(InputStream is)
119     {
120         this.is = is;
121         t = new GobblerThread();
122         t.setDaemon(true);
123         t.start();
124     }
125 
126     public int read() throws IOException
127     {
128         synchronized (synchronizer)
129         {
130             if (isClosed)
131                 throw new IOException("This StreamGobbler is closed.");
132 
133             while (read_pos == write_pos)
134             {
135                 if (exception != null)
136                     throw exception;
137 
138                 if (isEOF)
139                     return -1;
140 
141                 try
142                 {
143                     synchronizer.wait();
144                 }
145                 catch (InterruptedException e)
146                 {
147                     throw new InterruptedIOException();
148                 }
149             }
150 
151             int b = buffer[read_pos++] & 0xff;
152 
153             return b;
154         }
155     }
156 
157     public int available() throws IOException
158     {
159         synchronized (synchronizer)
160         {
161             if (isClosed)
162                 throw new IOException("This StreamGobbler is closed.");
163 
164             return write_pos - read_pos;
165         }
166     }
167 
168     public int read(byte[] b) throws IOException
169     {
170         return read(b, 0, b.length);
171     }
172 
173     public void close() throws IOException
174     {
175         synchronized (synchronizer)
176         {
177             if (isClosed)
178                 return;
179             isClosed = true;
180             isEOF = true;
181             synchronizer.notifyAll();
182             is.close();
183         }
184     }
185 
186     public int read(byte[] b, int off, int len) throws IOException
187     {
188         if (b == null)
189             throw new NullPointerException();
190 
191         if ((off < 0) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0) || (off > b.length))
192             throw new IndexOutOfBoundsException();
193 
194         if (len == 0)
195             return 0;
196 
197         synchronized (synchronizer)
198         {
199             if (isClosed)
200                 throw new IOException("This StreamGobbler is closed.");
201 
202             while (read_pos == write_pos)
203             {
204                 if (exception != null)
205                     throw exception;
206 
207                 if (isEOF)
208                     return -1;
209 
210                 try
211                 {
212                     synchronizer.wait();
213                 }
214                 catch (InterruptedException e)
215                 {
216                     throw new InterruptedIOException();
217                 }
218             }
219 
220             int avail = write_pos - read_pos;
221 
222             avail = (avail > len) ? len : avail;
223 
224             System.arraycopy(buffer, read_pos, b, off, avail);
225 
226             read_pos += avail;
227 
228             return avail;
229         }
230     }
231 }
View Code

如果使用这个类之前知悉读类的说明信息是可以看明白这个类存在的问题的。当然也可以从源码上看出来,我就是从源码看出问题的,当时花的时间肯定比看说明耗费的时间长。

下面是产生问题的代码:

 1 class GobblerThread extends Thread
 2     {
 3         public void run()
 4         {
 5             byte[] buff = new byte[8192];
 6 
 7             while (true)
 8             {
 9                 try
10                 {
11                     int avail = is.read(buff);
12 
13                     synchronized (synchronizer)
14                     {
15                         if (avail <= 0)
16                         {
17                             isEOF = true;
18                             synchronizer.notifyAll();
19                             break;
20                         }
21                         
22                         int space_available = buffer.length - write_pos;
23                         
24                         if (space_available < avail)
25                         {
26                             /* compact/resize buffer */
27 
28                             int unread_size = write_pos - read_pos;
29                             int need_space = unread_size + avail;
30 
31                             byte[] new_buffer = buffer;
32 
33                             if (need_space > buffer.length)
34                             {
35                                 int inc = need_space / 3;
36                                 inc = (inc < 256) ? 256 : inc;
37                                 inc = (inc > 8192) ? 8192 : inc;
38                                 new_buffer = new byte[need_space + inc];
39                             }
40                             
41                             if (unread_size > 0)
42                                 System.arraycopy(buffer, read_pos, new_buffer, 0, unread_size);
43 
44                             buffer = new_buffer;
45                             
46                             read_pos = 0;
47                             write_pos = unread_size;
48                         }
49                         
50                         System.arraycopy(buff, 0, buffer, write_pos, avail);
51                         write_pos += avail;
52 
53                         synchronizer.notifyAll();
54                     }    
55                 }
56                 catch (IOException e)
57                 {
58                     synchronized (synchronizer)
59                     {
60                         exception = e;
61                         synchronizer.notifyAll();
62                         break;
63                     }
64                 }
65             }
66         }
67     }
View Code

StreamGobbler类的buffer属性是一个只会不断增长,且不会清空的byte数组,问题就出在这里。

当一个Hive查询的执行时间非常的长(比如出现数据倾斜导致查询进行不下去、执行任务很多需要排队导致时间边长),那么这个线程将持续很长时间,而它将hold这个buffer永远不会被回收,虽然它里面的内容再也不会被使用。

那么这就是不合理的地方。StreamGobbler类的设计就是启动一个线程将一个输入流的内容不停的清空,读到自己的缓存中。这样的目的是不要造成流的堵塞,但这样就不适用长任务且日志不停输出的场景。

 

至此排查分析结束,原因就是第三方的StreamGobbler并不适合当前的场景。解决的办法就是自己实现读取流的线程及时的处理掉流中的内容,和StreamGobbler起一个线程去读试一致的,只是不做缓存处理。

 

经过这次CPU飙高查到原因,基本已经熟悉了JVM工具的使用,CPU问题及内存问题的排查流程,算是有些收获。看问题,排查定位问题,看源码分析,最终解决掉问题的过程让自己非常的“爽”,并且得到成长。

 

和各位博友一起成长,加油。

 

 

 

 

 

 

 

 

如果本文对您有帮助,点一下右下角的“推荐”
目录
相关文章
|
2月前
|
存储
阿里云轻量应用服务器收费标准价格表:200Mbps带宽、CPU内存及存储配置详解
阿里云香港轻量应用服务器,200Mbps带宽,免备案,支持多IP及国际线路,月租25元起,年付享8.5折优惠,适用于网站、应用等多种场景。
735 0
|
4月前
|
前端开发 算法 API
构建高性能图像处理Web应用:Next.js与TailwindCSS实践
本文分享了构建在线图像黑白转换工具的技术实践,涵盖技术栈选择、架构设计与性能优化。项目采用Next.js提供优秀的SSR性能和SEO支持,TailwindCSS加速UI开发,WebAssembly实现高性能图像处理算法。通过渐进式处理、WebWorker隔离及内存管理等策略,解决大图像处理性能瓶颈,并确保跨浏览器兼容性和移动设备优化。实际应用案例展示了其即时处理、高质量输出和客户端隐私保护等特点。未来计划引入WebGPU加速、AI增强等功能,进一步提升用户体验。此技术栈为Web图像处理应用提供了高效可行的解决方案。
|
1月前
|
弹性计算 前端开发 NoSQL
2025最新阿里云服务器配置选择攻略:CPU、内存、带宽与系统盘全解析
本文详解2025年阿里云服务器ECS配置选择策略,涵盖CPU、内存、带宽与系统盘推荐,助你根据业务需求精准选型,提升性能与性价比。
|
2月前
|
SQL 缓存 安全
深度理解 Java 内存模型:从并发基石到实践应用
本文深入解析 Java 内存模型(JMM),涵盖其在并发编程中的核心作用与实践应用。内容包括 JMM 解决的可见性、原子性和有序性问题,线程与内存的交互机制,volatile、synchronized 和 happens-before 等关键机制的使用,以及在单例模式、线程通信等场景中的实战案例。同时,还介绍了常见并发 Bug 的排查与解决方案,帮助开发者写出高效、线程安全的 Java 程序。
155 0
|
2月前
|
存储 弹性计算 固态存储
阿里云服务器配置费用整理,支持一万人CPU内存、公网带宽和存储IO性能全解析
要支撑1万人在线流量,需选择阿里云企业级ECS服务器,如通用型g系列、高主频型hf系列或通用算力型u1实例,配置如16核64G及以上,搭配高带宽与SSD/ESSD云盘,费用约数千元每月。
203 0
|
2月前
|
运维 安全 算法
服务器 CPU 占用忽高忽低?排查这 6 个隐藏进程,90% 的异常都能解决
服务器运维中,CPU占用忽高忽低常由隐藏进程引发,影响服务稳定性。本文介绍六大需排查的隐藏进程:异常编译、挖矿程序、内存泄漏、网络请求异常、日志轮转问题及恶意软件。通过排查工具如top、ps、netstat等定位问题进程,并提供针对性解决方法,帮助开发者快速稳定服务器性能。
621 0
|
3月前
|
缓存 前端开发 应用服务中间件
Web端实时通信技术SSE在携程机票业务中的实践应用
本文介绍了携程机票前端基于Server-Sent Events(SSE)实现服务端推送的企业级全链路通用技术解决方案。文章深入探讨了 SSE 技术在应用过程中包括方案对比、技术选型、链路层优化以及实际效果等多维度的技术细节,为类似使用场景提供普适性参考和借鉴。该方案设计目标是实现通用性,适用于各种网络架构和业务场景。
93 1
|
4月前
|
数据可视化 Linux iOS开发
Python测量CPU和内存使用率
这些示例帮助您了解如何在Python中测量CPU和内存使用率。根据需要,可以进一步完善这些示例,例如可视化结果或限制程序在特定范围内的资源占用。
178 22
|
4月前
|
缓存 前端开发 应用服务中间件
Web端实时通信技术SSE在携程机票业务中的实践应用
本文介绍了携程机票前端基于Server-Sent Events(SSE)实现服务端推送的企业级全链路通用技术解决方案。文章深入探讨了 SSE 技术在应用过程中包括方案对比、技术选型、链路层优化以及实际效果等多维度的技术细节,为类似使用场景提供普适性参考和借鉴。
126 7