我有一个自制的ETL解决方案。转换层在JavaScript scriptlet中的配置文件中定义,由Java的Nashorn引擎解释。
我遇到了性能问题。也许没有什么可以做的,但我希望有人可以找到我使用Nashorn帮助的方式的问题。这个过程是多线程的。
我创建了一个静态ScriptEngine,它仅用于创建CompiledScript对象。
private static ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
我将在每条记录上重新执行的scriptlet编译成CompiledScript对象。
public static CompiledScript compile(Reader reader) throws ScriptException {
return ((Compilable) engine).compile(reader);
}
还有两个使用此方法编译的标准JavaScript库。
对于每条记录,都会创建一个ScriptContext,添加标准库,并将记录的值设置为绑定。
public static ScriptContext getContext(List<CompiledScript> libs, Map<String, ? extends Object> variables) throws ScriptException {
SimpleScriptContext context = new SimpleScriptContext();
Bindings bindings = context.getBindings(ScriptContext.ENGINE_SCOPE);
for (CompiledScript lib : libs) {
lib.eval(context);
}
for (Entry<String, ? extends Object> variable : variables.entrySet()) {
bindings.put("$" + variable.getKey(), variable.getValue());
}
return context;
}
记录的上下文随后用于转换记录和评估过滤器,所有这些都使用CompiledScripts。
public static String evalToString(CompiledScript script, ScriptContext context) throws ScriptException {
return script.eval(context).toString();
}
针对ScriptContext的CompiledScripts的实际执行速度非常快,但ScriptContexts的初始化非常慢。不幸的是,至少据我所知,这必须按照一组绑定来完成。如果记录与过滤器匹配,那么我必须为同一记录第二次重建上下文,这次是来自匹配过滤器的一些额外绑定。
在我创建ScriptContext的任何时候都必须重新执行两个标准库似乎非常低效,但是我发现在执行这些库之后但在添加绑定之前克隆ScriptContext没有线程安全的方法。如果匹配过滤器,重新执行两个标准库并重新附加记录中的所有绑定似乎也非常低效,但我再次发现没有线程安全方法来克隆记录的ScriptContext以附加另一个绑定而不改变它原来。
根据jvisualvm,我节目的大部分时间花在
上jdk.internal.dynalink.support.AbstractRelinkableCallSite.initialize() (70%)
jdk.internal.dynalink.ChainedCallSite.relinkInternal() (14%)
我很感激Nashorn的任何见解都有助于提高此用例的性能。谢谢。
答案 0 :(得分:1)
我能够成功使用ThreadLocal来避免串扰。这会运行1,000,000次测试以观察串扰,但没有找到。这个改变意味着我创建了~4个ScriptContext对象而不是大约8,000,000个。
package com.foo;
import java.util.UUID;
import java.util.stream.Stream;
import javax.script.Bindings;
import javax.script.Compilable;
import javax.script.CompiledScript;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.script.SimpleScriptContext;
public class Bar {
private static ScriptEngine engine;
private static CompiledScript lib;
private static CompiledScript script;
// Use ThreadLocal context to avoid cross-talk
private static ThreadLocal<ScriptContext> context;
static {
try {
engine = new ScriptEngineManager().getEngineByName("JavaScript");
lib = ((Compilable) engine)
.compile("var firstChar = function(value) {return value.charAt(0);};");
script = ((Compilable) engine).compile("firstChar(myVar)");
context = ThreadLocal.withInitial(() -> initContext(lib));
} catch (ScriptException e) {
e.printStackTrace();
}
}
// A function to initialize a ScriptContext with a base library
private static ScriptContext initContext(CompiledScript lib) {
ScriptContext context = new SimpleScriptContext();
try {
lib.eval(context);
} catch (ScriptException e) {
e.printStackTrace();
}
return context;
}
// A function to set the variable binding, evaluate the script, and catch
// the exception inside a lambda
private static String runScript(CompiledScript script,
ScriptContext context, String uuid) {
Bindings bindings = context.getBindings(ScriptContext.ENGINE_SCOPE);
bindings.put("myVar", uuid);
String result = null;
try {
result = ((String) script.eval(context));
} catch (ScriptException e) {
e.printStackTrace();
}
return result;
}
// The driver function which generates a UUID, uses Nashorn to get the 1st
// char, uses Java to get the 1st char, compares them and prints mismatches.
// Theoretically if there was cross-talk, the variable binding might change
// between the evaluation of the CompiledScript and the java charAt.
public static void main(String[] args) {
Stream.generate(UUID::randomUUID)
.map(uuid -> uuid.toString())
.limit(1000000)
.parallel()
.map(uuid -> runScript(script, context.get(), uuid)
+ uuid.charAt(0))
.filter(s -> !s.substring(0, 1).equals(s.substring(1, 2)))
.forEach(System.out::println);
}
}