考虑我们有一个预定的执行程序服务:

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(...);

对于某些逻辑，我们希望重试任务执行。以下方法对我来说似乎很奇怪，但我不明白为什么:

threadPool.submit(new Runnable() {
    @Override
    public void run() {
        // ...
        if (needToBeScheduled()) {
           threadPool.schedule(this, delay, TimeUnit.MINUTES);
        } else if (needToBeResubmitted()) {
           threadPool.submit(this);
        }
    }
});

我看到的一个明显问题是这段代码无法转换为 lambda:

threadPool.submit(()-> {
    // ...
    if (needToBeScheduled()) {
        threadPool.schedule(this, delay, TimeUnit.MINUTES);
    } else if (needToBeResubmitted()) {
        threadPool.submit(this);
    }
});

^^ 这不会编译，因为我们不能从 lambda 引用 this。虽然它可以通过引入一种方法来解决，该方法产生这样一个实例并提供它而不是 this。

但这只是我看到的一个缺点。这里还有什么可能导致任何问题吗？也许有更合适的方法？将此逻辑移动到 ThreadPoolExecutor.afterExecute()(虽然这会导致类型转换...)？

假设对象是无状态的，即 Runnable 实例中没有对象变量。

P.S. 做什么的逻辑(重新安排任务或重新提交或什么都不做)是基于从数据库(或任何外部来源)检索的一些信息。所以 Runnable 仍然是无状态的，但它会根据其工作的一些结果来计算结果。

最佳答案

老实说，我不喜欢任务(一个简单的独立工作单元)决定它是否应该将自己放在服务中并与 ExecutorService 交互的方法。直接地。我相信// ...是任务应该执行的唯一部分。

我会转换一个 Runnable在Callable<Boolean> :

Callable<Boolean> task = () -> {
    // ...
    return needToBeScheduled; // or sth more complex with several boolean fields
};

而且我肯定会将该逻辑移到任务之外(例如，移到服务方法中):

Future<Boolean> future = threadPool.submit(task);

try {
    boolean needToBeScheduled = future.get();

    if (needToBeScheduled) {
        threadPool.schedule(task, delay, TimeUnit.MINUTES);
    }
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

我所说的更复杂的东西是指包含 2 boolean 的类领域。需要Supplier<Boolean>让事情变得懒惰。

final class TaskResult {
    private final Supplier<Boolean> needToBeScheduled;
    private final Supplier<Boolean> needToBeResubmitted;

    private TaskResult(Supplier<Boolean> needToBeScheduled, Supplier<Boolean> needToBeResubmitted) {
        this.needToBeScheduled = needToBeScheduled;
        this.needToBeResubmitted = needToBeResubmitted;
    }

    public static TaskResult of(Supplier<Boolean> needToBeScheduled, Supplier<Boolean> needToBeResubmitted) {
        return new TaskResult(needToBeScheduled, needToBeResubmitted);
    }

    public boolean needToBeScheduled() {
        return needToBeScheduled != null && needToBeScheduled.get();
    }

    public boolean needToBeResubmitted() {
        return needToBeResubmitted != null && needToBeResubmitted.get();
    }
}

对上面的例子做一些改动，我们有:

Callable<TaskResult> task = () -> {
    // ...
    return TaskResult.of(() -> needToBeScheduled(), () -> needToBeResubmitted());
};

final Future<TaskResult> future = threadPool.submit(task);

try {
    final TaskResult result = future.get();

    if (result.needToBeScheduled()) {
        threadPool.schedule(task, delay, TimeUnit.MINUTES);
    }

    if (result.needToBeResubmitted()) {
        threadPool.submit(task);
    }
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

关于java - 从任务本身重新提交/安排任务 - 这是一个好习惯吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49054279/