Question

我有一个Java方法，可以对输入集执行两次计算：估计和准确的答案。估计总是可以廉价地在可靠的时间内计算出来。准确答案有时可以在可接受的时间内计算出来，有时候不会（不知道先验......必须试着看）。

我想要设置的是一些框架，如果准确答案花费太长时间（固定超时），则使用预先计算的估计。我想我会使用一个线程。主要的复杂因素是计算准确答案的代码依赖于外部库，因此我无法“注入”中断支持。

此问题的独立测试用例就在这里，展示了我的问题：

package test;

import java.util.Random;

public class InterruptableProcess {
    public static final int TIMEOUT = 1000;

    public static void main(String[] args){
        for(int i=0; i<10; i++){
            getAnswer();
        }
    }

    public static double getAnswer(){
        long b4 = System.currentTimeMillis();
        // have an estimate pre-computed
        double estimate = Math.random();

        //try to get accurate answer
        //can take a long time
        //if longer than TIMEOUT, use estimate instead
        AccurateAnswerThread t = new AccurateAnswerThread();
        t.start();

        try{
            t.join(TIMEOUT);
        } catch(InterruptedException ie){
            ;
        }

        if(!t.isFinished()){
            System.err.println("Returning estimate: "+estimate+" in "+(System.currentTimeMillis()-b4)+" ms");
            return estimate;
        } else{
            System.err.println("Returning accurate answer: "+t.getAccurateAnswer()+" in "+(System.currentTimeMillis()-b4)+" ms");
            return t.getAccurateAnswer();
        }

    }

    public static class AccurateAnswerThread extends Thread{
        private boolean finished = false;
        private double answer = -1;

        public void run(){
            //call to external, non-modifiable code
            answer = accurateAnswer();
            finished = true;
        }

        public boolean isFinished(){
            return finished;
        }

        public double getAccurateAnswer(){
            return answer;
        }

        // not modifiable, emulate an expensive call
        // in practice, from an external library
        private double accurateAnswer(){
            Random r = new Random();
            long b4 = System.currentTimeMillis();
            long wait = r.nextInt(TIMEOUT*2);

            //don't want to use .wait() since
            //external code doesn't support interruption
            while(b4+wait>System.currentTimeMillis()){
                ;
            }
            return Math.random();
        }
    }
}

这可以正常输出......

Returning estimate: 0.21007465651836377 in 1002 ms
Returning estimate: 0.5303547292361411 in 1001 ms
Returning accurate answer: 0.008838428149438915 in 355 ms
Returning estimate: 0.7981717302567681 in 1001 ms
Returning estimate: 0.9207406241557682 in 1000 ms
Returning accurate answer: 0.0893839926072787 in 175 ms
Returning estimate: 0.7310211480220586 in 1000 ms
Returning accurate answer: 0.7296754467596422 in 530 ms
Returning estimate: 0.5880164300851529 in 1000 ms
Returning estimate: 0.38605296260291233 in 1000 ms

但是，我有一个非常大的输入集（大约数十亿项）来运行我的分析，我不确定如何清理未完成的线程（我不想要它们在后台运行）。

我知道破坏线程的各种方法都被弃用了。我也知道停止线程的典型方法是使用中断。但是，在这种情况下，我没有看到我可以使用中断，因为run()方法将单个调用传递给外部库。

在这种情况下如何杀死/清理线程？

Answer 1

如果您对外部库有足够的了解，例如：

永远不会获得任何锁;
永远不会打开任何文件/网络连接;
从不涉及任何I / O，甚至没有记录;

然后可以安全地使用Thread#stop。您可以尝试并进行广泛的压力测试。任何资源泄漏都应该很快就会显现出来。

Answer 2

我试试看它是否会响应一个Thread.interrupt（）。当然减少你的数据所以它不会永远运行，但如果它响应一个中断（）那么你就可以免费回家了。如果他们锁定任何东西，执行wait（）或sleep（），代码将必须处理InterruptedException，并且作者可能做了正确的事情。他们可能吞下它并继续，但有可能他们没有。

虽然从技术上讲你可以调用Thread.stop（），你需要知道关于该代码的一切，以确定它是否安全并且你不会泄漏资源。但是，进行这项研究将使您了解如何轻松修改代码以查找interrupt（）。您几乎必须拥有源代码来审核它以确定哪些意味着您可以轻松地做正确的事情并在那里添加检查，而不需要花费太多的研究来知道调用Thread.stop（）是否安全。

另一个选项是在线程中导致RuntimeException。尝试清空它可能具有的引用或关闭一些IO（套接字，文件句柄等）。通过更改大小或清空数据来修改它所遍历的数据数组。你可以做些什么来使它抛出一个异常并且没有处理它会关闭。

Answer 3

扩展chubbsondubs的答案，如果第三方库使用一些定义良好的API（例如java.util.List或某些特定于库的API）来访问输入数据集，则可以包装输入数据设置您传递给第三方代码的包装类将抛出异常，例如在List.get方法中，在设置cancel标志后。

例如，如果您将List传递给第三方库，则可能会执行以下操作：

class CancelList<T> implements List<T> {
  private final List<T> wrappedList;
  private volatile boolean canceled = false;

  public CancelList(List<T> wrapped) { this.wrappedList = wrapped; }

  public void cancel() { this.canceled = true; }

  public T get(int index) {
    if (canceled) { throw new RuntimeException("Canceled!"); }
    return wrappedList.get(index);
  }

  // Other List method implementations here...
}

public double getAnswer(List<MyType> inputList) {
  CancelList<MyType> cancelList = new CancelList<MyType>(inputList);
  AccurateAnswerThread t = new AccurateAnswerThread(cancelList);
  t.start();

  try{
    t.join(TIMEOUT);
  } catch(InterruptedException ie){
    cancelList.cancel();
  }

  // Get the result of your calculation here...
}

当然，这种方法取决于一些事情：

您必须足够了解第三方代码，以了解您可以通过输入参数控制的调用方法。
第三方代码需要在整个计算过程中频繁调用这些方法（即如果它将所有数据一次复制到内部结构并在那里进行计算，它将无法工作。）
显然，如果库捕获并处理运行时异常并继续处理，这将不起作用。

用Java清理线程

3 个答案: