JVM FULL GC 生产问题笔记

故事的开始

早晨 8 点多，同事给我发了一条消息。

“跑批程序很慢，负载过高，上午帮忙看一下。”

我一边走路，一遍回复好的，整个人都是懵的，一方面是因为没睡饱，另一方面是因为对同事的程序一无所知。

而这，就是今天整个故事的开始。

问题的定位

 

到了公司，简单了解情况之后，开始登陆机器，查看日志。

一看好家伙，最简单的一个请求 10S+，换做实时链路估计直接炸锅了。

于是想到两种可能：

(1)数据库有慢 SQL，归档等严重影响性能的操作

(2)应用 FULL GC

于是让 DBA 帮忙定位是否有第一种情况的问题，自己登陆机器看是否有 FULL GC。

初步的解决

 

十几分钟后，DBA 告诉我确实有慢 SQL，已经 kill 掉了。

GC 日志

不过查看 GC 日志的道路却一点都不顺利。

(1)发现应用本身没打印 gc log

(2)想使用 jstat 发现 docker 用户没权限，醉了。

于是让配管帮忙重新配置 jvm 参数加上 gc 日志，幸运的是，这个程序属于跑批程序，可以随时发布。

剩下的就等同事来了，下午验证一下即可。

FULL-GC 的源头

 

慢的源头

有了 GC 日志之后，很快就定位到慢是因为一直在发生 full gc 导致的。

那么为什么会一直有 full gc 呢?

jvm 配置的调整

一开始大家都以为是 jvm 的新生代配置的太小了，于是重新调整了 jvm 的参数配置。

结果很不幸，执行不久之后还是会触发 full gc。

要定位 full gc 的源头，只有开始看代码了。

代码与需求

 

需求

首先说一下应用内需要解决的问题还是比较简单的。

把数据库里的数据全部查出来，依次执行处理，不过有两点需要注意：

(1)数据量相对较大，百万级

(2)单条数据处理比较慢，希望处理的尽可能快。

业务简化

为了便于大家理解，我们这里简化所有的业务，使用最简单的 User 类来模拟业务。

• User.java

基本的数据库实体。

1. /** 
2.  * 用户信息 
3.  * @author binbin.hou 
4.  * @since 1.0.0 
5.  */ 
6. public class User { 
7.  
8.     private Integer id; 
9.  
10.     public Integer getId() { 
11.         return id; 
12.     } 
13.  
14.     public void setId(Integer id) { 
15.         this.id = id; 
16.     } 
17.  
18.     @Override 
19.     public String toString() { 
20.         return "User{" + 
21.                 "id=" + id + 
22.                 '}'; 
23.     } 
24.  
25. } 

•  UserMapper.java

模拟数据库查询操作。

1. public class UserMapper { 
2.  
3.     // 总数，可以根据实际调整为 100W+ 
4.     private static final int TOTAL = 100; 
5.  
6.     public int count() { 
7.         return TOTAL; 
8.     } 
9.  
10.     public List<User> selectAll() { 
11.         return selectList(1, TOTAL); 
12.     } 
13.  
14.     public List<User> selectList(int pageNum, int pageSize) { 
15.         List<User> list = new ArrayList<User>(pageSize); 
16.  
17.         int start = (pageNum - 1) * pageSize; 
18.         for (int i = start; i < start + pageSize; i++) { 
19.             User user = new User(); 
20.             user.setId(i); 
21.             list.add(user); 
22.         } 
23.  
24.         return list; 
25.     } 
26.  
27.     /** 
28.      * 模拟用户处理 
29.      * 
30.      * @param user 用户 
31.      */ 
32.     public void handle(User user) { 
33.         try { 
34.             // 模拟不同的耗时 
35.             int id = user.getId(); 
36.             if(id % 2 == 0) { 
37.                 Thread.sleep(100); 
38.             } else { 
39.                 Thread.sleep(200); 
40.             } 
41.         } catch (InterruptedException e) { 
42.             e.printStackTrace(); 
43.         } 
44.         System.out.println(System.currentTimeMillis() + " " + Thread.currentThread().getName() + " " + user); 
45.     } 
46.  
47. } 

这里提供了几个简单的方法，这里为了演示方便，将总数固定为 100。

• UserService.java

定义需要处理所有实体的一个接口。

1. /** 
2.  * 用户服务接口 
3.  * @author binbin.hou 
4.  * @since 1.0.0 
5.  */ 
6. public interface UserService { 
7.  
8.  
9.     /** 
10.      * 处理所有的用户 
11.      */ 
12.     void handleAllUser(); 
13.  
14. } 

 v1-全部加载到内存

 

最简单粗暴的方式，就是把所有数据直接加载到内存。

1. public class UserServiceAll implements UserService { 
2.  
3.  
4.     /** 
5.      * 处理所有的用户 
6.      */ 
7.     public void handleAllUser() { 
8.         UserMapper userMapper = new UserMapper(); 
9.         // 全部加载到内存 
10.  
11.         List<User> userList = userMapper.selectAll(); 
12.         for(User user : userList) { 
13.             // 处理单个用户 
14.             userMapper.handle(user); 
15.         } 
16.     } 
17.  
18. } 

这种方式非常的简单，容易理解。

不过缺点也比较大，数据量较大的时候会直接把内存打爆。

我也尝试了一下这种方式，应用直接假死，所以不可行。

v2-分页加载到内存

 

既然不能一把加载，那我很自然的就想到分页。

1. /** 
2.  * 分页查询 
3.  * @author binbin.hou 
4.  * @since 1.0.0 
5.  */ 
6. public class UserServicePage implements UserService { 
7.  
8.     /** 
9.      * 处理所有的用户 
10.      */ 
11.     public void handleAllUser() { 
12.         UserMapper userMapper = new UserMapper(); 
13.         // 分页查询 
14.         int total = userMapper.count(); 
15.         int pageSize = 10; 
16.  
17.         int totalPage = total / pageSize; 
18.         for(int i = 1; i <= totalPage; i++) { 
19.             System.out.println("第" + i + " 页查询开始"); 
20.             List<User> userList = userMapper.selectList(i, pageSize); 
21.  
22.             for(User user : userList) { 
23.                 // 处理单个用户 
24.                 userMapper.handle(user); 
25.             } 
26.         } 
27.     } 
28.  
29. } 

一般这样处理也就够了，不过因为想追求更快的处理速度，同事使用了多线程，大概实现如下。

v3-分页多线程

 

这里使用 Executor 线程池进行单个数据的消费处理。

主要注意点有两个地方：

(1)使用 sublist 控制每一个线程处理的数据范围

(2)使用 CountDownLatch 保证当前页处理完成后，才进行到下一次分页的查询和处理。

1. import com.github.houbb.thread.demo.dal.entity.User; 
2. import com.github.houbb.thread.demo.dal.mapper.UserMapper; 
3. import com.github.houbb.thread.demo.service.UserService; 
4.  
5. import java.util.List; 
6. import java.util.concurrent.CountDownLatch; 
7. import java.util.concurrent.Executor; 
8. import java.util.concurrent.Executors; 
9.  
10. /** 
11.  * 分页查询多线程 
12.  * @author binbin.hou 
13.  * @since 1.0.0 
14.  */ 
15. public class UserServicePageExecutor implements UserService { 
16.  
17.     private static final int THREAD_NUM = 5; 
18.  
19.     private static final Executor EXECUTOR = Executors.newFixedThreadPool(THREAD_NUM); 
20.  
21.     /** 
22.      * 处理所有的用户 
23.      */ 
24.     public void handleAllUser() { 
25.         UserMapper userMapper = new UserMapper(); 
26.         // 分页查询 
27.         int total = userMapper.count(); 
28.         int pageSize = 10; 
29.  
30.         int totalPage = total / pageSize; 
31.         for(int i = 1; i <= totalPage; i++) { 
32.             System.out.println("第 " + i + " 页查询开始"); 
33.             List<User> userList = userMapper.selectList(i, pageSize); 
34.  
35.             // 使用多线程处理 
36.             int count = userList.size(); 
37.             int countPerThread = count / THREAD_NUM; 
38.  
39.             // 通过 CountDownLatch 保证当前分页执行完成，才继续下一个分页的处理。 
40.             CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM); 
41.             for(int j = 0; j < THREAD_NUM; j++) { 
42.                 int startIndex = j * countPerThread; 
43.                 int endIndex = startIndex + countPerThread; 
44.                 // 最后一个 
45.                 if(j == THREAD_NUM - 1) { 
46.                     endIndex = count; 
47.                 } 
48.  
49.                 final int finalStartIndex = startIndex; 
50.                 final int finalEndIndex = endIndex; 
51.                 EXECUTOR.execute(()->{ 
52.                     List<User> subList = userList.subList(finalStartIndex, finalEndIndex); 
53.                     handleList(subList); 
54.  
55.                     // countdown 
56.                     countDownLatch.countDown(); 
57.                 }); 
58.             } 
59.  
60.  
61.             try { 
62.                 countDownLatch.await(); 
63.  
64.                 System.out.println("第 " + i + " 页查询全部完成"); 
65.             } catch (InterruptedException e) { 
66.                 e.printStackTrace(); 
67.             } 
68.         } 
69.     } 
70.  
71.     private void handleList(List<User> userList) { 
72.         UserMapper userMapper = new UserMapper(); 
73.  
74.         // 处理 
75.         for(User user : userList) { 
76.             // 处理单个用户 
77.             userMapper.handle(user); 
78.         } 
79.     } 
80.  
81. } 

这个实现是有一点复杂，但是第一感觉还是没啥问题。

为什么就 full gc 了呢?

sublist 的坑

 

这里使用了 sublist 方法，性能很好，也达到了分割范围的作用。

不过一开始，我却怀疑这里导致了内存泄漏。

SubList 的源码：

1. private class SubList extends AbstractList<E> implements RandomAccess { 
2.         private final AbstractList<E> parent; 
3.         private final int parentOffset; 
4.         private final int offset; 
5.         int size; 
6.  
7.         SubList(AbstractList<E> parent, 
8.                 int offset, int fromIndex, int toIndex) { 
9.             this.parent = parent; 
10.             this.parentOffset = fromIndex; 
11.             this.offset = offset + fromIndex; 
12.             this.size = toIndex - fromIndex; 
13.             this.modCount = ArrayList.this.modCount; 
14.         } 
15. } 

可以看出SubList原理：

1. 保存父ArrayList的引用;
2. 通过计算offset和size表示subList在原始list的范围;

由此可知，这种方式的subList保存对原始list的引用，而且是强引用，导致GC不能回收，故而导致内存泄漏，当程序运行一段时间后，程序无法再申请内存，抛出内存溢出错误。

解决思路是使用工具类替代掉 sublist 方法，缺点是内存占用会变多，比如：

1. /** 
2.  * @author binbin.hou 
3.  * @since 1.0.0 
4.  */ 
5. public class ListUtils { 
6.  
7.     @SuppressWarnings("all") 
8.     public static List copyList(List list, int start, int end) { 
9.         List results = new ArrayList(); 
10.         for(int i = start; i < end; i++) { 
11.             results.add(list.get(i)); 
12.         } 
13.         return results; 
14.     } 
15.  
16. } 

经过实测，发现并不是这个原因导致的。orz

lambda 的坑

 

因为使用的 jdk8，所以大家也就习惯性的使用 lambda 表达式。

1. EXECUTOR.execute(()->{ 
2.     //... 
3. }); 

这里实际上是一个语法糖，会导致 executor 引用 sublist。

因为 executor 的生命周期是非常长的，从而会让 sublist 一直得不到释放。

后来把代码调整了如下，full gc 也确认解决了。

v4-分页多线程 Task

 

我们使用 Task，让 sublist 放在 task 中去处理。

1. public class UserServicePageExecutorTask implements UserService { 
2.  
3.     private static final int THREAD_NUM = 5; 
4.  
5.     private static final Executor EXECUTOR = Executors.newFixedThreadPool(THREAD_NUM); 
6.  
7.     /** 
8.      * 处理所有的用户 
9.      */ 
10.     public void handleAllUser() { 
11.         UserMapper userMapper = new UserMapper(); 
12.         // 分页查询 
13.         int total = userMapper.count(); 
14.         int pageSize = 10; 
15.  
16.         int totalPage = total / pageSize; 
17.         for(int i = 1; i <= totalPage; i++) { 
18.             System.out.println("第 " + i + " 页查询开始"); 
19.             List<User> userList = userMapper.selectList(i, pageSize); 
20.  
21.             // 使用多线程处理 
22.             int count = userList.size(); 
23.             int countPerThread = count / THREAD_NUM; 
24.  
25.             // 通过 CountDownLatch 保证当前分页执行完成，才继续下一个分页的处理。 
26.             CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM); 
27.             for(int j = 0; j < THREAD_NUM; j++) { 
28.                 int startIndex = j * countPerThread; 
29.                 int endIndex = startIndex + countPerThread; 
30.                 // 最后一个 
31.                 if(j == THREAD_NUM - 1) { 
32.                     endIndex = count; 
33.                 } 
34.  
35.                 Task task = new Task(countDownLatch, userList, startIndex, endIndex); 
36.                 EXECUTOR.execute(task); 
37.             } 
38.  
39.             try { 
40.                 countDownLatch.await(); 
41.  
42.                 System.out.println("第 " + i + " 页查询全部完成"); 
43.             } catch (InterruptedException e) { 
44.                 e.printStackTrace(); 
45.             } 
46.         } 
47.     } 
48.  
49.     private void handleList(List<User> userList) { 
50.         UserMapper userMapper = new UserMapper(); 
51.  
52.         // 处理 
53.         for(User user : userList) { 
54.             // 处理单个用户 
55.             userMapper.handle(user); 
56.         } 
57.     } 
58.  
59.     private class Task implements Runnable { 
60.  
61.         private final CountDownLatch countDownLatch; 
62.  
63.         private final List<User> allList; 
64.  
65.         private final int startIndex; 
66.  
67.         private final int endIndex; 
68.  
69.         private Task(CountDownLatch countDownLatch, List<User> allList, int startIndex, int endIndex) { 
70.             this.countDownLatch = countDownLatch; 
71.             this.allList = allList; 
72.             this.startIndex = startIndex; 
73.             this.endIndex = endIndex; 
74.         } 
75.  
76.         @Override 
77.         public void run() { 
78.             try { 
79.                 List<User> subList = allList.subList(startIndex, endIndex); 
80.                 handleList(subList); 
81.             } catch (Exception exception) { 
82.                 exception.printStackTrace(); 
83.             } finally { 
84.                 countDownLatch.countDown(); 
85.             } 
86.         } 
87.     } 
88.  
89. } 

我们这里做了一点上面没有考虑到的点，countDownLatch 可能无法被执行，导致线程被卡主。

于是我们把 countDownLatch.countDown(); 放在 finally 中去执行。

辛苦搞了大半天，按理说到这里故事应该就结束了，不过现实比理论更加梦幻。

实际执行的时候，这个程序总是会卡主一段时间，导致整体的效果很差，还没有不适用多线程的效果好。

和其他同事沟通了一下，还是建议使用 生产-消费者 模式去实现比较好，原因如下：

(1)实现相对简单，不会产生奇奇怪怪的 BUG

(2)相对于 countDownLatch 的强制等待，生产-消费者模式可以做到基本无锁，性能更好。

于是，我晚上就花时间写了一个简单的 demo。

 v5-生产消费者模式

 

这里我们使用 ArrayBlockingQueue 作为阻塞队列，也就是消息的存储媒介。

当然，你也可以使用公司的 mq 中间件来实现类似的效果。

1. import com.github.houbb.thread.demo.dal.entity.User; 
2. import com.github.houbb.thread.demo.dal.mapper.UserMapper; 
3. import com.github.houbb.thread.demo.service.UserService; 
4.  
5. import java.util.List; 
6. import java.util.concurrent.*; 
7.  
8. /** 
9.  * 分页查询-生产消费 
10.  * @author binbin.hou 
11.  * @since 1.0.0 
12.  */ 
13. public class UserServicePageQueue implements UserService { 
14.  
15.     // 分页大小 
16.     private final int pageSize = 10; 
17.  
18.     private static final int THREAD_NUM = 5; 
19.  
20.     private final Executor executor = Executors.newFixedThreadPool(THREAD_NUM); 
21.  
22.     private final ArrayBlockingQueue<User> queue = new ArrayBlockingQueue<>(2 * pageSize, true); 
23.  
24.     // 模拟注入 
25.     private UserMapper userMapper = new UserMapper(); 
26.  
27.     // 消费线程任务 
28.     public class ConsumerTask implements Runnable { 
29.  
30.         @Override 
31.         public void run() { 
32.             while (true) { 
33.                 try { 
34.                     // 会阻塞直到获取到元素 
35.                     User user = queue.take(); 
36.                     userMapper.handle(user); 
37.                 } catch (InterruptedException e) { 
38.                     e.printStackTrace(); 
39.                 } 
40.             } 
41.         } 
42.     } 
43.  
44.     // 初始化消费者进程 
45.     // 启动五个进程去处理 
46.     private void startConsumer() { 
47.         for(int i = 0; i < THREAD_NUM; i++) { 
48.             ConsumerTask task = new ConsumerTask(); 
49.             executor.execute(task); 
50.         } 
51.     } 
52.  
53.     /** 
54.      * 处理所有的用户 
55.      */ 
56.     public void handleAllUser() { 
57.         // 启动消费者 
58.         startConsumer(); 
59.  
60.         // 分页查询 
61.         int total = userMapper.count(); 
62.         int pageSize = 10; 
63.  
64.         int totalPage = total / pageSize; 
65.         for(int i = 1; i <= totalPage; i++) { 
66.             // 等待消费者处理已有的信息 
67.             awaitQueue(pageSize); 
68.  
69.             System.out.println("第 " + i + " 页查询开始"); 
70.             List<User> userList = userMapper.selectList(i, pageSize); 
71.  
72.             // 直接往队列里面扔 
73.             queue.addAll(userList); 
74.  
75.             System.out.println("第 " + i + " 页查询全部完成"); 
76.         } 
77.     } 
78.  
79.     /** 
80.      * 等待，直到 queue 的小于等于 limit，才进行生产处理 
81.      * 
82.      * 首先判断队列的大小，可以调整为0的时候，才查询。 
83.      * 不过因为查询也比较耗时，所以可以调整为小于 pageSize 的时候就可以准备查询 
84.      * 从而保障消费者不会等待太久 
85.      * @param limit 限制 
86.      */ 
87.     private void awaitQueue(int limit) { 
88.         while (true) { 
89.             // 获取阻塞队列的大小 
90.             int size = queue.size(); 
91.  
92.             if(size >= limit) { 
93.                 try { 
94.                     System.out.println("当前大小：" + size + ", 限制大小: " + limit); 
95.                     // 根据实际的情况进行调整 
96.                     Thread.sleep(100); 
97.                 } catch (InterruptedException e) { 
98.                     e.printStackTrace(); 
99.                 } 
100.             } else { 
101.                 break; 
102.             } 
103.         } 
104.     } 
105. } 

整体的实现确实简单很多，因为查询比处理一般要快，所以往队列中添加元素时，这里进行了等待。

当然可以根据你的实际业务进行调整等待时间等。

这里保证小于等于 pageSize 时才插入新的元素，保证不超过队列的总长度，同时尽可能的让消费者不会进入空闲等待状态。

小结

 

总的来说，造成 full gc 的原因一般都是内存泄漏。

GC 日志真的很重要，遇到问题一定要记得添加上，这样才能更好的分析解决问题。

很多技术知识，我们以为熟悉了，往往还是存在不少坑。

要永远记得如无必要，勿增实体。

原文地址:https://www.toutiao.com/i6948809403172651534/