JVM调优——Java动态编译过程中的内存溢出问题

由于测试环境项目每2小时内存就溢出一次， 分析问题，发现Java动态加载Class并运行那块存在内存溢出问题， 遂本地调测。

一、找到动态编译那块的代码，具体如下

1. 
   
2. /**
3. * @MethodName: 编译java代码到Object
4. * @Description
5. * @param fullClassName 类名
6. * @param javaCode 类代码
7. * @return Object
8. * @throws IllegalAccessException
9. * @throws InstantiationException
10. */
11. public Class javaCodeToObject(String fullClassName, String javaCode) throws IllegalAccessException, InstantiationException {
12. Object instance = null;
13. //获取系统编译器
14. JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
15. // 建立DiagnosticCollector对象
16. DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
18. // 建立用于保存被编译文件名的对象
19. // 每个文件被保存在一个从JavaFileObject继承的类中
20. ClassFileManager fileManager = new ClassFileManager(compiler.getStandardFileManager(diagnostics, null, null));
22. List<JavaFileObject> jfiles = new ArrayList<>();
23. jfiles.add(new CharSequenceJavaFileObject(fullClassName, javaCode));
25. //使用编译选项可以改变默认编译行为。编译选项是一个元素为String类型的Iterable集合
26. List<String> options = new ArrayList<>();
27. options.add("-encoding");
28. options.add("UTF-8");
29. options.add("-classpath");
30. options.add(this.classpath);
31. //不使用SharedNameTable （jdk1.7自带的软引用，会影响GC的回收，jdk1.9已经解决）
32. options.add("-XDuseUnsharedTable");
34. JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, options, null, jfiles);
36. // 编译源程序
37. boolean success = task.call();
39. if (success) {
40. //如果编译成功，用类加载器加载该类
41. JavaClassObject jco = fileManager.getJavaClassObject();
42. DynamicClassLoader dynamicClassLoader = new DynamicClassLoader(this.parentClassLoader);
43. Class clazz = dynamicClassLoader.loadClass(fullClassName,jco);
44. try {
45. dynamicClassLoader.close();
46. //卸载ClassLoader所加载的类
47. ClassLoaderUtil.releaseLoader(dynamicClassLoader);
48. } catch (IOException e) {
49. e.printStackTrace();
50. }
51. return clazz;
52. } else {
53. //如果想得到具体的编译错误，可以对Diagnostics进行扫描
54. String error = "";
55. for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
56. error = error + compilePrint(diagnostic);
57. }
58. }
59. return null;
60. }

二、本地写测试类，并且启动执行

本地动态加载1000个类，测试查看内存空间变化

1. 
   
2. public static void main(String[] args) {
4. String code = "import java.util.HashMap;\n" +
5. "import com.yunerp.web.vaadin.message.alert;\n" +
6. "import java.util.List;\n" +
7. "import java.util.ArrayList;\n" +
8. "import com.yunerp.web.vaadin.util.modularfuntion.base.BaseUtil;\n" +
9. "import com.yunerp.web.vaadin.util.function.TableFuntionUtil;\n" +
10. "import com.yunerp.web.vaadin.util.modularfuntion.stoUtil.StoUtil;\n" +
11. "import java.util.Map;import com.yunerp.web.vaadin.util.modularfuntion.user.mini.HomePageUtil;\n" +
12. "import com.yunerp.web.util.run.WebInterface;\n" +
13. "\n" +
14. "public class web2905763164651825363 implements WebInterface {\n" +
15. " public Object execute(Map<String,Object> param) {\n" +
16. " System.out.println(param.get(\"key\"));" +
17. " return null;\n" +
18. " }\n" +
19. "}";
20. String name = "web2905763164651825363";
22. for(int i=0;i<1000;i++){
23. long time1 = System.currentTimeMillis();
24. DynamicEngine de = DynamicEngine.getInstance();
25. try {
26. Class cl = de.javaCodeToObject(name,code);
27. WebInterface webInterface = (WebInterface)cl.newInstance();
28. Map<String,Object> param = new HashMap<>();
29. param.put("key",i);
30. webInterface.execute(param);
32. }catch (Exception e) {
33. e.printStackTrace();
34. }
35. System.gc();
36. long time2 = System.currentTimeMillis();
37. System.out.println("次数："+i+" time:"+(time2-time1));
38. }
39. }

三、使用JConsole和JVisualVM工具进行检测。

工具的使用方法：JConsole和JVisualVM工具使用

本地项目启动后，使用JConsole和 JVisualVM工具进行检测，发现在动态加载类时， 堆空间内存直线上升，但是所加载的类和实例都被释放了，而且ClassLoader也释放了，但是内存还是在 上升，发现结果如下：

在查看堆空间快照的时候，发现JDK自带的 com.sun.tools.javac.util.SharedNameTable.NameImpl 类及其实例所在的内存空间比达到52%。 具体如下：

四、分析问题

查了很多文献，也问了很多朋友，都对SharedNameTable这个类很陌生,最终还是在google上找到我想要的解答。具体如下两个链接

链接：https://stackoverflow.com/questions/14617340/memory-leak-when-using-jdk-compiler-at-runtime

大概意思是：

Java 7引入了这个错误：为了加速编译，他们引入了SharedNameTable，它使用软引用来避免重新分配，但不幸的是只会导致JVM膨胀失控，因为这些软引用永远不会被回收直到JVM达到-Xmx内存限制。据称它将在Java 9中修复。与此同时，还有一个（未记录的）编译器选项来禁用它：-XDuseUnsharedTable。

参考链接2：https://stackoverflow.com/questions/33548218/memory-leak-in-program-using-compiler-api

五、 内存溢出问题解决

在编译选项options中加入 "-XDuseUnsharedTable" ，重新编译运行，内存溢出问题解决

1. 
   
2. //使用编译选项可以改变默认编译行为。编译选项是一个元素为String类型的Iterable集合
3. List<String> options = new ArrayList<>();
4. options.add("-encoding");
5. options.add("UTF-8");
6. options.add("-classpath");
7. options.add(this.classpath);
8. //不使用SharedNameTable （jdk1.7自带的软引用，会影响GC的回收，jdk1.9已经解决）
9. options.add("-XDuseUnsharedTable");

重新运行的效果图如下：

至此，问题完美解决。