动态执行Groovy脚本会遇到一个问题，那就是写Groovy脚本的人整活，在脚本里写了一个死循环。这时候整个系统就都GG了。

解决方案

在一个线程池里运行groovy脚本，如果线程运行超时就杀死这个线程

核心代码

  1. private ExecutorService executor = Executors.newCachedThreadPool();
  2. private int scriptTimeout = 1000;
  4. try {
  5.     future = invoke(method, instance);
  6.     return future.get(scriptTimeout, TimeUnit.MILLISECONDS);
  7. // 超时
  8. } catch (TimeoutException e) {
  9.     killFutureThread(future);
  10.     getLogger().error(e.toString(), e);
  11.     return false;
  12. // interrupt 
  13. } catch (InterruptedException e) {
  14.     future.cancel(true);
  15.     throw e;
  16. // 执行异常
  17. } catch (ExecutionException e) {
  18.      Throwable cause = t.getCause();
  19.     if(cause instanceof InvocationTargetException) {
  20.         // InvocationTargetException 的异常栈不一样
  21.          getLogger().error("执行错误", ((InvocationTargetException) cause).getTargetException());
  22.     }else{
  23.         getLogger().error("执行错误", StackTraceUtils.deepSanitize(cause));
  24.     }
  25. } finally {
  26.     bindings.clear();
  27. }
  29. public FutureTask<Boolean> invoke(Method method, Script instance){
  30.     return (FutureTask<Boolean>) executor.submit(() -> {
  31.         return (boolean) method.invoke(instance);
  32.     });
  33. }
  35. // 单纯的future.cancel() 只有在线程阻塞时才会停掉线程，如果线程里是一个不会sleep的死循环，就无法成功停止。
  36. // 这种情况下只能通过Thread.stop()来强行杀掉线程(这是一个因为比较危险所以被标记为废弃的函数)。
  37. public void killFutureThread(FutureTask future){
  38.     try {
  39.         if (future.isDone()) {
  40.             return;
  41.         }
  43.         // 利用反射，强行取出正在运行该任务的线程
  44.         // 发现FutureTask有两种实现，目前开发使用的oracle java8和Linux上的openjdk8 / openjdk11，Thread都是直接作为私有属性runner
  45.         // 但是看到老的GNU的实现Thread属性是藏在FutureTask.Sync.runner属性，需要多反射一次Sync (http://fuseyism.com/classpath/doc/java/util/concurrent/FutureTask-source.html)
  46.         // 虽然只支持第一种在不通环境测试都通过了，还是做一下兼容
  47.         Thread execThread = null;
  48.         try{
  49.             Field runner = FutureTask.class.getDeclaredField("runner");
  50.             runner.setAccessible(true);
  51.             execThread = (Thread) runner.get(future);
  52.         }catch(NoSuchFieldException e) {
  53.             Field sync = FutureTask.class.getDeclaredField("sync");
  54.             sync.setAccessible(true);
  55.             Object obj = sync.get(future);
  57.             Field runner = obj.getClass().getDeclaredField("runner");
  58.             runner.setAccessible(true);
  59.             execThread = (Thread) runner.get(obj);
  60.         }
  62.         if (execThread == null) {
  63.             return;
  64.         }
  65.         Thread.State state = execThread.getState();
  66.         if (state == Thread.State.RUNNABLE) {
  67.             execThread.stop();// 非阻塞线程才STOP，例如死循环
  68.         }
  69.         // 其他情况cancel里会使用interrupt()方式，例如sleep、wait等等
  70.         future.cancel(true);
  71.     } catch (Exception e) {
  72.         getLogger().error("杀死超时的线程失败");
  73.     }
  74. }