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); 从不同的线程和提供绑定不共享它是线程安全的？
• 或者这是否意味着对脚本有一些限制,因此他们应该在任何共享对象上同步？.我的理解是,这似乎是正确的答案.
• 或者是其他东西 ？

如果答案可以用一些代码说明,那将是很好的.

Answer 1

不幸的是,如果涉及到GroovyScriptEngineImpl课堂,这些信息会产生误导.你提到的Javadoc说:

"MULTITHREADED" - 引擎实现在内部是线程安全的,并且脚本可以并发执行,尽管脚本执行对一个线程的影响可能对其他线程上的脚本可见.

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

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

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在运行此脚本后打印绑定时,我们将看到它在执行期间不会更改.但是y++在这种情况下增加了y绑定值.

在第二个脚本中,我们定义局部变量def y = 10,并将local y(10在本例中)的值添加到当前全局x绑定值.

如您所见,两个脚本都修改了全局绑定.在这篇文章中显示的示例代码中,我们同时运行两个脚本20次.我们不知道两个脚本的执行顺序(假设每次执行都有一个随机超时,因此一个脚本可能会挂起几秒钟).我们在内部bindings使用ConcurrentHashMap所以我们只有在并发访问时才是安全的 - 两个线程不会同时更新相同的绑定.但我们不知道结果是什么.每次执行后.第一级循环执行4次,内部循环执行5次,在每次执行期间,它使用共享脚本引擎和共享绑定提交脚本评估.此外,第一个任务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个不同的类加载器实例,而在第3个循环中我们打印了5个不同的类加载器实例)
• 最终绑定计算是非确定性的.我们已经避免了并发写入,ConcurrentHashMap但我们无法控制执行顺序,因此在依赖先前执行的绑定值的情况下,您永远不知道期望什么值.

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

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

希望能帮助到你.