Groovy大量计算导致oom的解决办法

最近在项目中遇到一个内存持续增长的问题，系统启动后内存使用原本很低，但是在系统运行的过程中，内存一直在慢慢的增加，最后机器发出了内存预警，查看使用的内存，短短一个月居然达到了8G，并且jvm无法回收这些内存。

经过一系列排查，发现是大量调用groovy脚本计算导致的，使用visualVM监控jvm已加载的类数量：

发现每次调用脚本，都会增加一个类，导致堆内存一直增加，问题代码：

    public static ScriptEngine engine = new ScriptEngineManager().getEngineByName("groovy");
    public static Map<String,Bindings> bindingMap = new HashMap<>(1);
    ...
    //根据当前线程得到引擎
    public static Bindings getEngineBinding(){
        return getEngineBinding(getCurrentThread());
    }
    //根据当前线程得到引擎
    public static Bindings getEngineBinding(String threadNum){
        return bindingMap.computeIfAbsent(threadNum, k -> engine.createBindings());
    }
    //根据当前线程得到引擎
    public static String getCurrentThread(){
        return Thread.currentThread().getName();
    }
    //问题代码
    public static boolean eval(Map<String,Object> map, String expression, String key) throws Exception {
        Bindings binding = getEngineBinding();
        binding.put(key,map);
        return (boolean) engine.eval(expression,binding);
    }

 原因分析：使用ScriptEngine.eval执行匿名表达式，每次都会对脚本进行编译，生成一个随机类名的类，被GroovyClassLoader加载，虽然GroovyClassLoader有提供clearCache()方法，但是这个并不能释放被占用的内存，因为这些加载的类也会被AppClassLoader中的map缓存，这个map只进不出，大量执行计算后，这个map中的groovy匿名类不断增加，最终OOM。

解决办法：对计算的表达式expression进行预编译，以表达式作为key，将编译好的类进行缓存，这样只会首次计算时去编译，后面再次计算时，根据expression从缓存里面取到对象，然后进行计算，不会再去创建类。修改后的代码：

    private static final Map<String,CompiledScript> scriptMap = new ConcurrentHashMap<>(100);
    public static CompiledScript getCompiledScript(String checkRule) throws ScriptException {
        CompiledScript script = scriptMap.get(checkRule);
        if(script == null){
            script = ((Compilable) engine).compile(checkRule);
            scriptMap.put(checkRule,script);
        }
        return script;
    }

    public static boolean eval(String expression,Bindings binding) throws Exception {
        CompiledScript script = getCompiledScript(expression);
        return (boolean) script.eval(binding);
    }

再次调用脚本计算，发现只有第一次加载了新的类，后面调用没有再创建加载新的类。

为了解决groovy引擎oom和消除并发计算之间的干扰，我封装一个工具类，不需要积分下载

https://download.csdn.net/download/qq_36635569/85471110

使用示例

    public static void main(String[] args) throws Exception{
        GroovyEngine engine = GroovyEngine.getInstance();
        //加载一个函数
        engine.loadExternalScript("/*多个数值求和*/\n" +
                "def sum(Number[] nums){\n" +
                "    if(nums==null || nums.length==0){\n" +
                "        return 0;\n" +
                "    }\n" +
                "    Number n=(nums[0] == null) ? 0 : nums[0];\n" +
                "    for(i=1;i<nums.length;i++){\n" +
                "        if(nums[i]!=null){\n" +
                "            n+=nums[i];\n" +
                "        }\n" +
                "    }\n" +
                "    return n;\n" +
                "}");
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(() -> {
                try {
                    //设置值
                    engine.put("a",1);
                    engine.put("b",2);
                    //计算
                    Object v1 = engine.eval("sum(a,b)");
                    Object v2 = engine.valid("sum(a,b)==a+b");
                    System.out.println(String.format("%s,%s",v1,v2));
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    //最后清空变量作用域，防止oom
                    GroovyEngine.cleanScope();
                }
            });
            t.start();
            t.join();
        }
    }