如何在提交给 ExecutorService 的任务中处理第三方 Java 代码，以防它有一个无限循环

Question

假设我有一个第三方Java库，在提交给ExecutorService的Task中调用。

我相信第三方库不是恶意的，但是很少有编程错误可能导致它陷入无限循环，如果是这种情况，我无法修复它来解决那些罕见的情况。

处理此问题以使应用程序也不会卡住的最佳方法是什么？shutdownNow()足以处理这种情况吗？

有一个相关的问题 停止执行器服务任务中的无限循环，但这依赖于程序员的合作能力并检测停止处理Thread.currentThread().isInterrupted()，这是我不能依赖的。

(就我而言，它是Jython代码;在Jython的早期版本中，解释器显然没有检查Thread.currentThread().isInterrupted()，不确定它现在做了什么......但我的问题对于任何第三方 Java 代码都是通用的。

Answer 1

如果任务有一个无限循环，该循环不检查线程中断状态，并且不使用抛出InterruptedException的方法，则不会由shutdownNow()停止。

不允许编程完成的简单示例：

public static void main(String[] args) throws Exception {
  ExecutorService e = Executors.newFixedThreadPool(1);
  e.submit(() -> { while (true); });
  e.shutdownNow();
  System.out.println("Main is finished but the app keeps running");
}

一种方法是将线程作为守护程序运行：

public static void main(String[] args) throws Exception {
  ExecutorService e = Executors.newFixedThreadPool(1, r -> {
      Thread t = new Thread(r);
      t.setDaemon(true);
      return t;
    });
  e.submit(() -> { while (true); });
  e.shutdownNow();
  System.out.println("Main is finished and the app can exit");
}

Answer 2

在我正确阅读问题之后，我整理了这组课程。相对简单：一个 Runnable，它连接到一个套接字，从调用不稳定库的辅助 jvm 发送输入和检索输出。

如果 3 次尝试后没有收到响应，则辅助 jvm 将被终止。但它可以重新启动。辅助 jvm 有一个用于关闭套接字的出口钩子。

class SafetyValve implements Runnable{
    PrintWriter out;
    BufferedReader in;
    Socket s = null;
    AtomicBoolean flag;
    SafetyValve(AtomicBoolean b){
        flag = b;
    }
    @Override
    public void run() {
        try {
            s = new Socket("localhost", 9000);
            out = new PrintWriter(s.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(s.getInputStream()));
            while (!Thread.currentThread().isInterrupted()){
                flag.set(false);
                out.print(0);
                out.flush();
                System.out.print(in.read());
                flag.set(true);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally{
            try {
                s.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

主/控制器类。它使用 Thread 类进行控制

public class Switch {
    public static void main(String[] args) {
        try {
            AtomicBoolean flag = new AtomicBoolean(false);
            int counter = 0;
            ProcessBuilder pb = ...
            pb.directory(,,,);
            Process p = pb.start();
            SafetyValve sv = new SafetyValve(flag);
            Thread t = new Thread(sv);
            t.start();
            while(t.getState() != Thread.State.RUNNABLE){
                Thread.sleep(10);
            }
            while(true){
                if (flag.get() == false){
                    if (++counter == 3){
                        while(t.getState() != Thread.State.TERMINATED){
                            p.destroyForcibly();
                            t.interrupt();
                            Thread.sleep(10);
                        }
                        break;
                    }
                }
                else
                    counter = 0;
                Thread.sleep(100);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

辅助 jvm 具有标准的服务器套接字实现：

class UnYielding{
    int i = 0;
    int returnInt(){
        i++;
        if (i > 2)
            while(true);
        return i;
    }
}
class Hook extends Thread{
    RunWild rw;
    Hook(RunWild wr){
        rw = wr;
    }
    public void run() {
        try {
            System.out.println("exit...");
            System.out.flush();
            rw.socket.close();
            rw.server.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
public class RunWild {
    ServerSocket server;
    Socket socket;
    RunWild(){
        Runtime.getRuntime().addShutdownHook(new Hook(this));
    }
    public static void main(String[] args){
        UnYielding u;
        int i;
        PrintWriter out;
        BufferedReader in;
        RunWild rw = new RunWild();
        try {
            rw.server = new ServerSocket(9000);
            rw.socket = rw.server.accept();
            out = new PrintWriter(rw.socket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(rw.socket.getInputStream()));
            u = new UnYielding();
            while ((i = in.read()) != -1){
                out.print(u.returnInt());
                out.flush();
                Thread.sleep(10);
                System.out.print("waiting...");
                System.out.flush();
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

我已经在OS X上针对1.8进行了测试，它按预期工作。如果需要这种不稳定的类，这是一种方法