java - Groovy ScriptingEngine 线程安全吗？

Question

当你打电话时:

 Object isThreadSafe = scriptEngine.getFactory().getParameter("THREADING");

它按照以下方式返回 MULTITHREADED:

• https://docs.oracle.com/javase/8/docs/api/javax/script/ScriptEngineFactory.html#getParameter-java.lang.String-

但目前还不清楚这到底有什么影响。

这是否意味着:

• 我可以调用 scriptEngine.eval(script, bindings);来自不同线程并且提供的绑定(bind)不共享它是线程安全的吗？
• 或者这是否意味着对脚本有一些限制，因此它们应该在任何共享对象上同步？。我的理解是这似乎是正确的答案。
• 或者其他什么？

如果答案可以用一些代码来说明就太好了。

Answer 1

不幸的是，如果涉及到 GroovyScriptEngineImpl ，此信息会产生误导。类(class)。您提到的 Javadoc 说:

"MULTITHREADED" - The engine implementation is internally thread-safe and scripts may execute concurrently although effects of script execution on one thread may be visible to scripts on other threads.

GroovyScriptEngineImpl不适用于此，因为例如您可以使用 GroovyScriptEngineImpl.setClassLoader(GroovyClassLoader classLoader) 更改类加载器方法，并且当它发生在并发执行时可能会导致不可预测的行为(这个方法甚至不是原子的，并且不会在线程之间同步执行)。

关于 scriptEngine.eval(script, bindings)执行，当你共享相同的 bindings 时，你必须意识到它的不确定性。跨越许多不同的线程。 javax.script.SimpleBindings 默认构造函数使用 HashMap你绝对应该避免它 - 在多线程执行的情况下最好使用 ConcurrentHashMap<String,Object>至少允许安全的并发访问。但是，即使您同时评估多个脚本并且这些脚本将更改全局绑定(bind)时也无法获得任何保证。考虑以下示例:

import org.codehaus.groovy.jsr223.GroovyScriptEngineImpl

import javax.script.ScriptContext
import javax.script.SimpleBindings
import javax.script.SimpleScriptContext
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.Future

class GroovyScriptEngineExample {

    static void main(args) {
        def script1 = '''
def x = 4
y++
x++
'''

        def script2 = '''
def y = 10
x += y
'''

        final GroovyScriptEngineImpl engine = new GroovyScriptEngineImpl()
        final ExecutorService executorService = Executors.newFixedThreadPool(5)

        (0..3).each {
            List<Future> tasks = []

            final SimpleBindings bindings = new SimpleBindings(new ConcurrentHashMap<String, Object>())
            bindings.put('x', 1)
            bindings.put('y', 1)

            (0..<5).each {
                tasks << executorService.submit {
                    engine.setClassLoader(new GroovyClassLoader())
                    engine.eval(script1, bindings)
                }
                tasks << executorService.submit {
                    println engine.getClassLoader()
                    engine.eval(script2, bindings)
                }
            }

            tasks*.get()

            println bindings.entrySet()
        }

        executorService.shutdown()
    }
}

在这个例子中，我们定义了两个 Groovy 脚本:

def x = 4
y++
x++

和:

def y = 10
x += y

在第一个脚本中我们定义了一个局部变量def x = 4和 x++仅增加我们的本地脚本变量。当我们打印 x运行此脚本后绑定(bind)我们将看到它在执行过程中不会改变。然而y++在这种情况下递增 y绑定(bind)值。

在第二个脚本中我们定义局部变量def y = 10我们增加了本地的值(value)y (在本例中为 10)到当前全局 x绑定(bind)值。

如您所见，这两个脚本都修改了全局绑定(bind)。在本文中显示的示例代码中，我们同时运行了两个脚本 20 次。我们不知道这两个脚本的执行顺序是什么(假设每次执行都有一个随机超时，所以一个脚本可能会挂起几秒钟)。我们的bindings使用 ConcurrentHashMap在内部，所以我们只有在并发访问时才是安全的——两个线程不会同时更新相同的绑定(bind)。但我们不知道结果如何。每次执行后。第一级循环执行 4 次，内部循环执行 5 次，在每次执行期间，它使用共享脚本引擎和共享绑定(bind)提交脚本评估。第一个任务也替换了 GroovyClassLoader在引擎中向您展示跨多个线程共享其实例是不安全的。您可以在下面找到示例性输出(示例性，因为每次运行很可能会得到不同的结果):

groovy.lang.GroovyClassLoader@1d6b34d4
groovy.lang.GroovyClassLoader@1d6b34d4
groovy.lang.GroovyClassLoader@64f061f1
groovy.lang.GroovyClassLoader@1c8107ef
groovy.lang.GroovyClassLoader@1c8107ef
[x=41, y=2]
groovy.lang.GroovyClassLoader@338f357a
groovy.lang.GroovyClassLoader@2bc966b6
groovy.lang.GroovyClassLoader@2bc966b6
groovy.lang.GroovyClassLoader@48469ff3
groovy.lang.GroovyClassLoader@48469ff3
[x=51, y=4]
groovy.lang.GroovyClassLoader@238fb21e
groovy.lang.GroovyClassLoader@798865b5
groovy.lang.GroovyClassLoader@17685149
groovy.lang.GroovyClassLoader@50d12b8b
groovy.lang.GroovyClassLoader@1a833027
[x=51, y=6]
groovy.lang.GroovyClassLoader@62e5f0c5
groovy.lang.GroovyClassLoader@62e5f0c5
groovy.lang.GroovyClassLoader@7c1f39b5
groovy.lang.GroovyClassLoader@657dc5d2
groovy.lang.GroovyClassLoader@28536260
[x=51, y=6]

一些结论:

• 替换 GroovyClassLoader是不确定的(在第一个循环中打印了 3 个不同的类加载器实例，而在第三个循环中我们打印了 5 个不同的类加载器实例)
• 最终绑定(bind)计算是不确定的。我们避免了与 ConcurrentHashMap 并发写入但我们无法控制执行顺序，因此如果依赖先前执行的绑定(bind)值，您永远不知道期望值是什么。

那么，在使用 GroovyScriptEngineImpl 时如何保证线程安全？在多线程环境中？

• 不要使用全局绑定(bind)
• 使用全局绑定(bind)时，请确保脚本不会覆盖绑定(bind)(您可以使用 new SimpleBindings(Collections.unmodifiableMap(map))
• 否则你必须接受 bindings 的非确定性状态修改
• 扩展GroovyScriptEngineImpl并且不允许在对象初始化后更改类加载器
• 否则接受一些其他线程可能会有点困惑。

希望对您有所帮助。