Java 延迟服务

是否有

ExecutorService

允许我提交任务而不开始执行，直到我请求它？我正在寻找类似于

ScheduledExecutorService

的东西，不同的是我希望在不依赖固定时间延迟的情况下手动触发执行

---

我之所以寻找它，是因为我想创建一组任务，这些任务可以递归地使用同一组中并行任务生成的

Future

s的结果。因此，我需要首先提交所有任务，以便获得一组

未来的
，只有这样，我才能允许任务开始执行。
也许另一种方法是简单地使用a或a

未来回调示例：

final List<ListenableFuture<T>> futures = new ArrayList<ListenableFuture<T>>();
final Callable<T> callable = new Callable<T>() {
    // Some task you want to complete
};
// Submit all your tasks for execution
futures.add(listeningExecutorService.submit(callable));
// ... add as many tasks as you have
futures.add(listeningExecutorService.submit(callable));

// Get a single Future to wait on
final ListenableFuture<List<T>> future = Futures.allAsList(futures);

Futures.addCallback(future, new FutureCallback<List<T>>() {
    @Override
    public void onSuccess(final List<T> result) {
        // Begin other tasks using `result` (the set of results from the first tasks)
    }
    @Override
    public void onFailure(final Throwable t) {
        // ...
    }
});

final List futures=new ArrayList（）；
final Callable Callable=new Callable（）{
//一些你想完成的任务
};
//提交所有任务以供执行
futures.add（listingexecutorservice.submit（callable））；
// ... 添加尽可能多的任务
futures.add（listingexecutorservice.submit（callable））；
//拥有一个可以等待的未来
最终可上市期货=期货。allAsList（期货）；
Futures.addCallback（future，newfuturecallback（）{
@凌驾
成功时公开作废（最终列表结果）{
//使用“result”（第一个任务的结果集）开始其他任务
}
@凌驾
失效时公共失效（最终可丢弃t）{
// ...
}
});

如果您不关心等待第二组任务完成，这将非常有用，因为不会返回任何内容

异步函数示例：

final ListenableFuture<O> result = Futures.transform(future, new AsyncFunction<List<T>, O>() {
    @Override
    public ListenableFuture<O> apply(final List<T> input) {
        // Begin other tasks using `input` (the set of results from the first tasks)
    }
});

final ListenableFuture result=Futures.transform（future，new AsyncFunction（））{
@凌驾
公共列表未来应用（最终列表输入）{
//使用“输入”（第一个任务的结果集）开始其他任务
}
});

如果您想等待结果，或者可能添加第三组任务，这些任务需要在第二组任务完成后执行，那么这将非常有用。
这听起来像是一个


以separe
CompletableFutures
然后使用创建一个只有在完成所有任务后才能完成的未来屏障
然后使用一个组合符，如
CompletableFuture。然后接受
来安排任务的下一部分，以便在将来完成时执行



但更惯用的使用方法是根据前一个任务的未来结果来链接下一个任务

CompletableFuture<FirstResult> firstTask = //....
CompletableFuture<SecondResult> secondTask = firstTask.thenApply(someTransformation);
CompletableFuture<Void> anotherTaks = firstTask.thenAccept(someConsumer);
CompletableFuture<ThirdResult> combined =  firstTask.thenAcceptBoth(secondTask, someFunction);

CompletableFuture firstTask=/。。。。
CompletableFuture secondTask=firstTask.thenApply（someTransformation）；
CompletableFuture anotherTaks=第一个任务，然后接受（某个消费者）；
CompletableFuture combined=第一个任务，然后接受两个任务（第二个任务，someFunction）；
+1我将重新考虑您是否可以简化您的执行模型。通常，一个看似好的想法，实际上非常复杂，难以有效地实现，使其值得。这似乎并不难实现。您可以为executor编写一个包装器，该包装器将使用
execute（）
方法返回某种修改的
Future
，并跟踪所有提交的任务，将它们存储在某个内部集合中。@PeterLawrey我正在考虑其他方法，但如果此功能确实存在，这可能是完成我的任务最简单的方法。我甚至可以考虑自己执行这样一个执行器。你可能不需要一个新的执行器，你只需要一个新的队列，就像一个延迟队列，在触发这些任务之前，不会出现新的任务（而不是在他们的时间到达时）。因为我需要一个非常具体的用例，关键是在我收集了所有未来的
之前，任何任务都不应该开始。这有什么帮助？我应该在我的回答中更清楚一点-我可以在回家后更新。也许我误解了你的问题，但听起来你有一套未来和一套任务，需要所有这些未来的结果才能执行，对吗？如果是这样的话，那么你可以将这些未来组合成一个单一的未来。然后，您可以对一个异步任务进行排队，该任务只有在给定的未来完成后才会执行。在这种情况下，给定的未来实际上包含所有这些第一个任务的结果，而不是另一组任务需要之前一组任务的结果。我希望一组任务在开始执行之前能够访问彼此的未来。啊，我现在明白了——我错了。出于好奇，你有没有找到一个好的解决方案？没有使用遗嘱执行人。我只是创建了一堆线程，然后启动它们。