从任务本身重新提交/安排任务 - 这是一个好习惯吗？

Question

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

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);
    }
});

^^这将无法编译,因为我们无法this从lambda 引用.虽然它可以通过引入一个产生这样一个实例的方法来解决,而不是提供它this.

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

假设该对象是无状态的,即Runnable实例中没有对象变量.

PS执行操作的逻辑(重新安排任务或重新提交或不执行任何操作)基于从数据库(或任何外部源)检索的某些信息.所以Runnable仍然是无国籍的,但它根据其工作的一些结果计算结果.

Answer 1

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

我会将 a 转换Runnable为 a 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>让事情变得懒惰需要s。

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();
}