Why Executor interface doesn't have a method, which takes Callable as a parameter?

Question

From this answer I learned that the only difference between Callable and Runnable is that former can return a result of the execution and throw an exception.

I don't understand why Executor doesn't define a method which takes a Callable:

void execute(Callable command);

From my point of view, it'd be logical to create methods for both Runnable and Callable. In ExecutorService, which is a subinterface of Executor, there are similar submit() methods for both Runnable and Callable.

Please, explain this design decision, because I can't find any explanation on the Internet.

Answer 1

I suppose the Executor design was meant to be as simple as possible, i.e. with one method. Since execute() doesn't provide any means of getting the result, it makes sense that it doesn't accept Callables, and takes only Runnables.

On the other hand, the various submit() functions return Futures, which can be used to both obtain a result (e.g. from a Callable), or to simply wait for the execution to finish. So, it makes sense to accept both Runnable and Callable.

Answer 2

Executors run tasks. They are needed if you want to manage how and when tasks should be run. Executors don't collect task results and thus support only Runnable.

Assume they support Callable. Then how should one fetch the result? T execute(Callable<T> command) is not an option as it will block current thread execution. So it should be paired with some T getResult() or return Future<T>. And for that you have ExecutorService with method <T> Future<T> submit(Callable<T> task).

Answer 3

I don't understand why Executor doesn't define a method which takes a Callable.

An Executor has a single responsibility - executing a submitted task. On this abstraction level, APIs that use only Runnables don't demand the additional features proposed by the ExecutorService.

It'd be logical to create methods for both Runnable and Callable.

Yes, therefore the ExecutorService interface was designed by extending the Executor. The ExecutorService offers a significant difference - providing results of task execution. That's why the Callable, TimeUnit, and lifecycle methods were added.