一次FULL GC问题的排查

时间  2019-11-09
标签 一次 问题 排查 栏目 Java 繁體版
原文   原文链接

1、背景

线上一个项目，每次机器重启时项目都会报出大量的Timeout，同时每一个集群节点都被监控到较为频繁的Full GC。以后同事虽然尝试过JVM调优并适当调大了老年代空间，但依然不能根本上解决问题。当时该问题被初步归咎于系统中整合的Groovy，但并未证明。问题汇总以下：java

  • 问题一：项目启动时报出大量Timeout；
  • 问题二：项目运行时，频繁Full GC；

随后，我着手作另一个项目GLUE，该项目一样须要整合Groovy，在作并发测试时，我发现了一样的问题。缓存

通过排查并作出优化，新项目GLUE在并发测试下基本不存在Full GC的问题，在此将问题处理过程记录以下，但愿能够给你们一点参考。数据结构

2、分析

新系统GLUE底层基于Groovy实现，系统经过执行 “groovy.lang.GroovyClassLoader.parseClass(groovyScript)” 进行Groovy代码解析，Groovy为了保证解析后执行的都是最新的脚本内容，每进行一次解析都会生成一次新命名的Class文件，底层代码以下图：并发

输入图片说明

所以，若是Groovy类加载器设置为单例，当对脚本（即便同一段脚本）屡次执行该方法时，会致使 “GroovyClassLoader” 装载的Class愈来愈多。若是此处临时加载的类不可以被及时释放，最终将会致使PermGen OutOfMemoryError。即便状况没有那么糟糕，也会引发频繁的full GC，从而影响稳定运行时的性能。app

而后，我翻阅了线上启动时大量Timeout以及Full GC的项目代码。发现该项目一样适用“GroovyClassLoader”进行groovy脚本解析，断点接入以下：异步

输入图片说明

首先，我发现该项目中的Groovy类加载器是单例； 其次，该项目中的加载一次页面，将会调用多达31次“groovy.lang.GroovyClassLoader.parseClass(groovyScript)”方法进行groovy脚本解析。这很震惊，可是庆幸的是，该系统对解析后的Class作了缓存。tcp

3、分析结果

通过分析，该项目启动是被报大量Timeout和运行Full GC的问题基本锁定，缘由以下：ide

  • 启动时Timeout缘由：项目启动完成后，该节点通过健康检查无误被切到线上集群环境，接收线上流量。可是，因为该项目上单个页面模块太多，上文中一张页面加载须要执行解析函数多达31次，并且该项目还托管这许多其余的页面，这致使这些页面的预热时间比较久。可是不幸的是，项目已经经过了健康检查，大量流量涌入阻塞等待页面加载完成，所以致使项目启动时被报大量Timeout。函数

  • 频繁Full GC缘由：该项目中Groovy类加载使用单例，当对脚本（即便同一段脚本）屡次执行该方法时，会致使 “GroovyClassLoader” 装载的Class愈来愈多。若是此处临时加载的类不可以被及时释放，最终将会致使PermGen OutOfMemoryError。即便状况没有那么糟糕，也会引发频繁的full GC，从而影响稳定运行时的性能。性能

3、验证

为了对上述猜测进行验证，设计了一下三段代码进行简单测试。代码逻辑分别为：

  • Test1.java：并行启动100个线程，并行解析groovy脚本，使用单例类加载器；
  • Test2.java：并行启动100个线程，并行解析groovy脚本，使用非单例类加载器；
  • Test3.java：并行启动100个线程，并行打印log。

本文中测试方法为，启动下面三段测试代码中的Main方法，经过查看各自JVM的GC状况从而验证GroovyClassLoader对JVM的影响。

代码A：Test1.java
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import groovy.lang.GroovyClassLoader;

public class Test {

	public static void main(String[] args) throws InterruptedException, IOException {
		final String code = readAll("DemoHandlerAImpl.groovy");
		final AtomicInteger count = new AtomicInteger(0);

		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 100; i++) {
			executorService.execute(new Runnable() {
				@Override
				public void run() {
					while (true) {
						try {
							TimeUnit.SECONDS.sleep(2);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						Object object = parseClass(code);
						System.out.println("COUNT1=" + count.incrementAndGet() + ", " + object.hashCode());
					}
				}
			});
		}

	}

	static GroovyClassLoader classLoader = new GroovyClassLoader();
	public static Object parseClass(String code){
		return classLoader.parseClass(code);
	}

	public static String readAll(String logFile){
		try {
			InputStream ins = null;
			BufferedReader reader = null;
			try {
				ins = new FileInputStream(Thread.currentThread().getContextClassLoader().getResource(logFile).getPath());
				reader = new BufferedReader(new InputStreamReader(ins, "utf-8"));
				if (reader != null) {
					String content = null;
					StringBuilder sb = new StringBuilder();
					while ((content = reader.readLine()) != null) {
						sb.append(content).append("\n");
					}
					return sb.toString();
				}
			} finally {
				if (ins != null) {
					try {
						ins.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				if (reader != null) {
					try {
						reader.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			} 
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}
代码2：Test2.java
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import groovy.lang.GroovyClassLoader;

public class Test2 {

	public static void main(String[] args) throws InterruptedException, IOException {
		final String code = readAll("DemoHandlerAImpl.groovy");
		final AtomicInteger count = new AtomicInteger(0);

		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 100; i++) {
			executorService.execute(new Runnable() {
				@Override
				public void run() {
					while (true) {
						try {
							TimeUnit.SECONDS.sleep(2);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						Object object = parseClass(code);
						System.out.println("COUNT2=" + count.incrementAndGet() + ", " + object.hashCode());
					}
				}
			});
		}

	}

	static GroovyClassLoader classLoader = new GroovyClassLoader();
	public static Object parseClass(String code){
		classLoader = new GroovyClassLoader();
		return classLoader.parseClass(code);
	}

	public static String readAll(String logFile){
		try {
			InputStream ins = null;
			BufferedReader reader = null;
			try {
				ins = new FileInputStream(Thread.currentThread().getContextClassLoader().getResource(logFile).getPath());
				reader = new BufferedReader(new InputStreamReader(ins, "utf-8"));
				if (reader != null) {
					String content = null;
					StringBuilder sb = new StringBuilder();
					while ((content = reader.readLine()) != null) {
						sb.append(content).append("\n");
					}
					return sb.toString();
				}
			} finally {
				if (ins != null) {
					try {
						ins.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				if (reader != null) {
					try {
						reader.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			} 
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}
代码3：Test3.java
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import groovy.lang.GroovyClassLoader;

public class Test3 {

	public static void main(String[] args) throws InterruptedException, IOException {
		final String code = readAll("DemoHandlerAImpl.groovy");
		final Object object = parseClass(code);

		final AtomicInteger count = new AtomicInteger(0);

		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 100; i++) {
			executorService.execute(new Runnable() {
				@Override
				public void run() {
					while (true) {
						try {
							TimeUnit.SECONDS.sleep(2);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

						System.out.println("COUNT3=" + count.incrementAndGet() + ", " + object.hashCode());
					}
				}
			});
		}

	}

	static GroovyClassLoader classLoader = new GroovyClassLoader();
	public static Object parseClass(String code){
		classLoader = new GroovyClassLoader();
		return classLoader.parseClass(code);
	}

	public static String readAll(String logFile){
		try {
			InputStream ins = null;
			BufferedReader reader = null;
			try {
				ins = new FileInputStream(Thread.currentThread().getContextClassLoader().getResource(logFile).getPath());
				reader = new BufferedReader(new InputStreamReader(ins, "utf-8"));
				if (reader != null) {
					String content = null;
					StringBuilder sb = new StringBuilder();
					while ((content = reader.readLine()) != null) {
						sb.append(content).append("\n");
					}
					return sb.toString();
				}
			} finally {
				if (ins != null) {
					try {
						ins.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				if (reader != null) {
					try {
						reader.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			} 
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}
测试Groovy脚本：DemoHandlerAImpl.groovy
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 场景A：托管 “配置信息” ，尤为适用于数据结构比较复杂的配置项
 * 优势：在线编辑；推送更新；+ 直观；
 * @author xuxueli 2016-4-14 15:36:37
 */
public class DemoHandlerAImpl  {

	public Object handle(Map<String, Object> params) {

		// 【基础类型配置】
		boolean ifOpen = true;															// 开关
		int smsLimitCount = 3;															// 短信发送次数阀值
		String brokerURL = "failover:(tcp://127.0.0.1:61616,tcp://127.0.0.2:61616)";	// 套接字配置

		// 【列表配置】
		Set<Integer> blackShops = new HashSet<Integer>();								// 黑名单列表
		blackShops.add(15826714);
		blackShops.add(15826715);
		blackShops.add(15826716);
		blackShops.add(15826717);
		blackShops.add(15826718);
		blackShops.add(15826719);

		// 【KV配置】
		Map<Integer, String> emailDispatch = new HashMap<Integer, String>();			// 不一样BU标题文案配置
		emailDispatch.put(555, "淘宝");
		emailDispatch.put(666, "天猫");
		emailDispatch.put(777, "聚划算");

		// 【复杂集合配置】
		Map<Integer, List<Integer>> openCitys = new HashMap<Integer, List<Integer>>();	// 不一样城市推荐商户配置
		openCitys.put(11, Arrays.asList(15826714, 15826715));
		openCitys.put(22, Arrays.asList(15826714, 15651231, 86451231));
		openCitys.put(33, Arrays.asList(48612323, 15826715));

		return smsLimitCount;
	}

}
在系统运行四分钟后，Test1.java对应JVM的GC如图：

输入图片说明

从日志能够发现，共解析groovy达38694次。 输入图片说明

在系统运行四分钟后，Test2.java对应JVM的GC如图：

输入图片说明

从日志能够发现，共解析groovy达39100次。 输入图片说明

在系统运行四分钟后，Test3.java对应JVM的GC如图：

输入图片说明

从日志能够发现，共解析groovy达40000次。 输入图片说明

3、测试结果分析

经过观察内存曲线图，能够获取测试结果：

  • Test1.java：Test1.java：PS MarkSweep有5次，PS Scavenge高达1210次，分散均匀；
  • Test2.java：Test2.java：PS MarkSweep有5次，PS Scavenge达到485次，分散均匀；
  • Test3.java：Test3.java：PS MarkSweep有0次，PS Scavenge仅5次，且仅在线程启动时触发PS Scavenge。

从上述测试结果能够获得结论：

  • 一、Groovy类加载器，频繁解析Groovy代码将会致使PS MarkSweep；
  • 二、单例Groovy类加载器，比非单例更容易致使PS Scavenge；
  • 三、单例和多实例Groovy类加载器方式，PS MarkSweep基本一致，由于两种方式parseClass生成的Class数量基本一致，即占用的PermGen空间基本一致，因此两种方式在Full GC上的表现基本一致，若是要减小Full GC，减小parseClass才是根本解决方法；可是两者PS Scavenge却有数倍的差异，是由于单例方式parseClass过程当中冗余大量的中间对象，这些中间对象会被PS Scavenge掉，不会引发大的问题。所以，减小parseClass次数才是解决的正途。

4、总结优化

  • 一、为避免启动时Timeout，应该在项目彻底预热完成后再切入线上环境；
  • 二、避免在在单次调用时触发屡次groovy脚本解析，解析过程自己比较耗时，可并行处理，或者将多个脚本合并为单个脚本；
  • 三、针对每一个groovy脚本解析后生成的Java对象实例作缓存，而不是代码自己作缓存；
  • 四、仅仅在接收到清除缓存的广播时解析生成新的Java实例对象，避免groovy的频繁解析，减小Class装载频率；
  • 五、周期性的异步刷新类加载器，避免因全局类加载器频繁parseClass致使的PS Scavenge。

PermGen回收

PermGen中对象回收规则：ClassLoader能够被回收，其下的全部加载过的没有对应实例的类信息（保存在PermGen）可被回收。所以，JVM回收以后，能够将GroovyClassLoader加载的冗余新信息回收掉。

可是。GC在JVM中一般是由一个或一组进程来实现的，它自己也和用户程序同样占用heap空间，运行时也占用CPU。所以，当GC运行时间较长时，用户可以感到 Java程序的停顿。所以，尽可能避免GC。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程