记一次程序内存占用高问题排查_auditd内存占用大

登录机器，查看内存占用

使用PID将内存占用DMUP下来

jmap -dump:format=b,file=heap.bin 23711
1

文件竟然6.2G

分析dump文件

分析结论：内存中存储的数据过大，需要清理

查看系统GC情况

jstat -gc 23711 1000
1

S0C：年轻代中第一个survivor（幸存区）的容量 （字节）
S1C：年轻代中第二个survivor（幸存区）的容量 (字节)
S0U ：年轻代中第一个survivor（幸存区）目前已使用空间 (字节)
S1U ：年轻代中第二个survivor（幸存区）目前已使用空间 (字节)
EC ：年轻代中Eden（伊甸园）的容量 (字节)
EU ：年轻代中Eden（伊甸园）目前已使用空间 (字节)
OC ：Old代的容量 (字节)
OU ：Old代目前已使用空间 (字节)
MC：metaspace(元空间)的容量 (字节)
MU：metaspace(元空间)目前已使用空间 (字节)
YGC ：从应用程序启动到采样时年轻代中gc次数
YGCT ：从应用程序启动到采样时年轻代中gc所用时间(s)
FGC ：从应用程序启动到采样时old代(全gc)gc次数
FGCT ：从应用程序启动到采样时old代(全gc)gc所用时间(s)
GCT：从应用程序启动到采样时gc用的总时间(s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

查看本进程被分配的内存

jinfo pid
1

查看内存占用前10的类

jmap -histo:live 23711  | sort -n -r -k 2 | head -20
1

分析原因：

内存中存在大数据对象放在hashMap中，并没有即时回收，造成内存占用越来越大。

解决方案

hashMap设置过期时间，将内存数据回收

cacheObject.java

/**
 * @program: javademo
 * @description:
 * @author: sunyuhua
 * @create: 2022-06-06 10:20
 **/
public class CacheObject {

 /**
  * 缓存对象
  */
 private Object value;

 /**
  * 生存时间
  */
 private long ttl;

 /**
  * 构造函数
  *
  * @param value 缓存对象
  * @param ttl 生存时间毫秒
  */
 public CacheObject(Object value, long ttl) {
  this.value = value;
  this.ttl = ttl;
 }

 public Object getValue() {
  return value;
 }

 public void setValue(Object value) {
  this.value = value;
 }

 public long getTtl() {
  return ttl;
 }

 public void setTtl(long ttl) {
  this.ttl = ttl;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

ConcurrentMapCache.java

/**
 * @program: javademo
 * @description:
 * @author: sunyuhua
 * @create: 2022-06-06 10:19
 **/
import org.apache.commons.lang3.ObjectUtils;

import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class ConcurrentMapCache {

 /**
  * 缓存对象
  */
 private ConcurrentMap<String, CacheObject> cache = new ConcurrentHashMap<String, CacheObject>();

 /**
  * 定时删除器
  */
 private Timer deleteTimer = null;

 /**
  * 默认删除时间(秒)
  */
 private static final int DEFAULT_DELETE_SECONDS = 5 * 60;

 public ConcurrentMapCache(int deleteSeconds) {
  this.initTimer(deleteSeconds);
 }

 public ConcurrentMapCache() {
  this.initTimer(0);
 }

 /**
  * 初始化定时器
  *
  * @param deleteSeconds
  */
 private void initTimer(int deleteSeconds) {

  if (deleteSeconds == 0) {
   deleteSeconds = DEFAULT_DELETE_SECONDS;
  }

  deleteTimer = new Timer();
  deleteTimer.schedule(new DeleteTask(), 0, deleteSeconds * 1000);
 }

 /**
  * 设置缓存
  *
  * @param key
  * @param value
  * @param expire 过期时间毫秒为单位
  */
 public void set(String key, Object value, long expire) {

  // ObjectUtils.isAnyEmpty 参数中只要存在empty即返回true
  if ( ObjectUtils.isEmpty(key) || ObjectUtils.isEmpty(expire) || ( expire < 0L && expire != -1 ) ) {
   return ;
  }

  CacheObject cacheObject = new CacheObject(value, expire == -1L ? expire : System.currentTimeMillis() + expire);

  this.cache.put(key, cacheObject);
 }

 /**
  * 设置过期时间
  * @param key
  * @param expire -1L长期有效
  */
 public void put(String key,long expire) {

  if ( ObjectUtils.isEmpty(key) || ObjectUtils.isEmpty(expire) || ( expire < 0L && expire != -1 ) ) {
   return ;
  }

  CacheObject cacheObject = this.cache.get(key);
  cacheObject.setTtl(expire == -1L ? expire : System.currentTimeMillis() + expire);
 }

 /**
  * 设置缓存
  *
  * @param key
  * @param value
  */
 public void set(String key, Object value) {

  this.set(key, value, -1L);

 }

 /**
  * 获取缓存
  */
 public Object get(String key) {

  if (this.check(key)) {
   return this.cache.get(key).getValue();
  }
  return null;
 }

 /**
  * 删除某个缓存
  */
 public void delete(String key) {

  this.cache.remove(key);

 }



 /**
  * 判断缓存是否有效（过期、不存在均返回false）
  */
 private boolean check(String key) {

  CacheObject cacheObject = this.cache.get(key);

  if (cacheObject == null) {
   return false;
  }

  if (cacheObject.getTtl() == -1L) {
   return true;
  }

  if (cacheObject.getTtl() < System.currentTimeMillis()) {
   delete(key);
   return false;
  }

  return true;
 }

 /**
  * 定时删除任务
  */
 class DeleteTask extends TimerTask {

  @Override
  public void run() {

   // 循环Map中数据，找到已经过期的数据进行删除
   for(Map.Entry<String, CacheObject> entry : cache.entrySet()) {

    if (entry.getValue().getTtl() < System.currentTimeMillis() && entry.getValue().getTtl() != -1L) {
     delete(entry.getKey());
    }
   }
	   this.cancel();
  }
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

测试类

/**
 * @program: javademo
 * @description:
 * @author: sunyuhua
 * @create: 2022-06-06 10:46
 **/
public class ConTest {
 public static void main(String[] args) {
  ConcurrentMapCache concurrentMapCache=new ConcurrentMapCache();
  concurrentMapCache.set("score","12:13:09",10*1000);

  Timer timer = new Timer();
  timer.schedule(new TimerTask() {
   @Override
   public void run() {
    System.out.println(concurrentMapCache.get("score"));
   }
  }, 0L, 1000L);
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

修改JVM参数配置：

JAVA_OPTS='-server -Xmn1g -Xms9g -Xmx9g -Xss512K -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:LargePageSizeInBytes=128m -XX:+UseFastAccessorMethods -XX:+UseCMSInitiatingOccupancyOnly -XX:CMSInitiatingOccupancyFraction=70 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/timerbackend_gc.hprof -XX:+ParallelRefProcEnabled  -XX:MetaspaceSize=512m -XX:MaxMetaspaceSize=1g'
1

辅助：

1、将项目中不必要的加载内存的地方去掉，减少内存占用

2、将通知类拿走，直接发送到MQ，MQ再做消费或者转发