Question

我想使用迭代加深来执行搜索，这意味着每次我都这样做，我会更深入，而且需要更长的时间。有一个时间限制（2秒）可以获得最佳结果。根据我的研究，最好的方法是使用ExecutorService，Future，并在时间用完时中断它。这就是我现在所拥有的：

在我的主要功能中：

ExecutorService service = Executors.newSingleThreadExecutor();
ab = new AB();
Future<Integer> f = service.submit(ab);
Integer x = 0;
try {
    x = f.get(1990, TimeUnit.MILLISECONDS);
}
catch(TimeoutException e) {
    System.out.println("cancelling future");
    f.cancel(true);
}
catch(Exception e) {
    throw new RuntimeException(e);
}
finally {
    service.shutdown();
}
System.out.println(x);

可赎回：

public class AB implements Callable<Integer> {

    public AB() {}

    public Integer call() throws Exception {
        Integer x = 0;
        int i = 0;
        while (!Thread.interrupted()) {
            x = doLongComputation(i);
            i++;
        }
        return x;
    }
}

我有两个问题：

doLongComputation（）没有被中断，程序只在完成工作后检查Thread.interrupted（）是否为true。我是否需要在doLongComputation（）中放入检查以查看该线程是否已被中断？
即使我摆脱了doLongComputation（），主方法也没有收到x的值。我怎样才能确保我的程序等待Callable“清理”并返回到目前为止最好的x？

Answer 1

要回答第1部分：是的，您需要让您的长任务检查中断的标志。中断需要中断任务的合作。

除非您特别想要清除中断标志，否则您应该使用Thread.currentThread().isInterrupted()。抛出（或重新抛出）InterruptedException的代码使用Thread#interrupted作为检查标志并清除它的便捷方式，当您编写Runnable或Callable时，这通常不是您想要的。

现在回答第2部分：取消不是你想要的。

使用取消来停止计算并返回中间结果不起作用，一旦取消将来，就无法从get方法中检索返回值。你可以做的是让计算的每个细化都是自己的任务，这样你就可以提交一个任务，获得结果，然后使用结果作为起点提交下一个任务，保存最新的结果。

这是我想出来的一个例子，用牛顿的方法计算平方根的连续近似值。每次迭代都是一个单独的任务，在前一个任务完成时提交（使用前一个任务的近似值）：

import java.util.concurrent.*;
import java.math.*;

public class IterativeCalculation {

    static class SqrtResult {
        public final BigDecimal value;
        public final Future<SqrtResult> next;
        public SqrtResult(BigDecimal value, Future<SqrtResult> next) {
            this.value = value;
            this.next = next;
        }
    }

    static class SqrtIteration implements Callable<SqrtResult> {
        private final BigDecimal x;
        private final BigDecimal guess;
        private final ExecutorService xs;
        public SqrtIteration(BigDecimal x, BigDecimal guess, ExecutorService xs) {
            this.x = x;
            this.guess = guess; 
            this.xs = xs;
        }

        public SqrtResult call() {
            BigDecimal nextGuess = guess.subtract(guess.pow(2).subtract(x).divide(new BigDecimal(2).multiply(guess), RoundingMode.HALF_EVEN));
            return new SqrtResult(nextGuess, xs.submit(new SqrtIteration(x, nextGuess, xs)));
        }
    }

    public static void main(String[] args) throws Exception {
        long timeLimit = 10000L;
        ExecutorService xs = Executors.newSingleThreadExecutor();
        try {
            long startTime = System.currentTimeMillis();
            Future<SqrtResult> f = xs.submit(new SqrtIteration(new BigDecimal("612.00"), new BigDecimal("10.00"), xs));
            for (int i = 0; System.currentTimeMillis() - startTime < timeLimit; i++) {
                f = f.get().next;                
                System.out.println("iteration=" + i + ", value=" + f.get().value);
            }
            f.cancel(true);
        } finally {
            xs.shutdown();
        }
    }
}

执行超时后返回的长计算

1 个答案: