1

这就是我所拥有的......我有一个任务列表，每个任务都将单独提交ExecutorService。我希望每个任务在开始执行后都有 x MS 的时间限制。我已经看到了类似在单个线程的时间限制上发布的解决方案，但这设置了从提交任务时开始的时间限制。

我认为一种解决方案是对Time Limit on Individual Threads的公认解决方案的扩展。这将包装Callable在另一个Callable中，一旦它开始就会将取消任务放在计划的执行程序上。这将涉及以一种非平凡的方式将 映射Callable到 ，Future所以我想我会发布以查看是否有人知道现有的解决方案（代码重用是一件很棒的事情）。

谢谢。

作为仅供参考，在单个线程的时间限制上发布的解决方案如下。这再次从提交时间取消，而不是开始时间：

ExecutorService service = Executors.newFixedThreadPool(N);
ScheduledExecutorService canceller = Executors.newSingleThreadScheduledExecutor();

public <T> Future<T> executeTask(Callable<T> c, long timeoutMS){
   final Future<T> future = service.submit(c);
   canceller.schedule(new Callable<Void>(){
       public Void call(){
          future.cancel(true);
          return null;
       }
    }, timeoutMS, TimeUnit.MILLI_SECONDS);
   return future;
}
4

4 回答 4

2

看看这是否适合你。

对不起，如果代码很混乱，但这只是为了演示这个概念：将未来传递给任务，让任务启动自己的计时器 - 计时器将在任务启动时启动。

以下代码添加了 10 个任务，每个任务执行时间为 2 秒，但超时时间为 1 秒。

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class CancellableTaskDemo {
    public static void main(final String[] args) {
        new CancellableTaskDemo();
    }

    final ExecutorService ex = Executors.newFixedThreadPool(3);

    public CancellableTaskDemo() {
        for (int i = 0; i < 10; i++) {
            final int c = i;
            submitTask(new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                    final long t = System.currentTimeMillis();
                    try {
                        Thread.sleep(2000);
                        System.out.println("Task " + c + " done in " + (System.currentTimeMillis() - t) + "ms");
                    } catch (final InterruptedException e) {
                        System.out.println("Task " + c + " aborted after " + (System.currentTimeMillis() - t) + "ms");
                    }
                    return null;
                }
            }, 1000);
        }
        ex.shutdown();
        try {
            ex.awaitTermination(100000, TimeUnit.MILLISECONDS);
        } catch (final InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void submitTask(final Callable<Object> c, final int timeout) {
        final TimedFutureTask tft = new TimedFutureTask(c, timeout);
        final Future<?> ft = ex.submit(tft.getCallable());
        tft.setFuture(ft);
    }

    static class TimedFutureTask {
        final static ScheduledExecutorService canceller = Executors.newSingleThreadScheduledExecutor();
        private Timer cancelTimer;
        private Callable<Object> timedCallable;
        private Future<?> f;
        private int timeoutMS;

        public TimedFutureTask(final Callable<Object> callable, final int timeoutMS) {
            this.timeoutMS = timeoutMS;
            timedCallable = (new Callable<Object>() {

                @Override
                public Object call() throws Exception {

                    cancelTimer = new Timer();
                    cancelTimer.schedule(new TimerTask() {

                        @Override
                        public void run() {
                            f.cancel(true);

                        }
                    }, timeoutMS);

                    final Object res = callable.call();
                    cancelTimer.cancel();
                    return res;
                }

            });
        }

        public Callable<Object> getCallable() {
            return timedCallable;
        }

        public void setFuture(final Future<?> future) {
            f = future;
        }
    }

}
于 2012-11-05T21:47:42.390 回答
0

我会使用 ScheduleExecutorService。

final Future future = es.submit(myTask);
ses.schedule(new Runnable() {
    public void run() {
        future.cancel(true);
    }
}, timeout, timeUnit);
于 2012-11-05T16:50:36.143 回答
0

您可以手动完成，但代码太多，无法完成简单的任务:( 

public void run() {
    long start = System.nanoTime();
    long timeout = 60 * 1000;
    do {
        // Do work here
    } while (TimeUnit.MICROSECONDS.convert(System.nanoTime() - start,
            TimeUnit.MICROSECONDS)
            - start > timeout);
}
于 2012-11-05T17:18:59.223 回答
0

您可以将计时器作为您提交的任务的一部分启动，因此它将在任务执行时启动。只是，在这种情况下，您不能使用future.cancel，但可以中断线程。根据您提交的任务，是否可以轻松地及时终止。

于 2012-11-05T17:19:46.770 回答