The ParallelExecutor service allows a computation to occur in parallel.

It can be used in two ways. First, with an explicit Future:

   Future<String> future = executor.invoke(new Invokable<String>() { ... });

The executor will submit the Invokable to a thread pool for execution in the background.

The ultimate value of the Invokable is available by invoking get() on the Future; this will block until the value is ready.

Other methods on Future can cancel the execution, or get the value only if it is ready within a timeout.

The thread pool is started automatically as needed, and will shutdown when the Registry itself is shutdown.

Another alternative will return an object proxy, not a Future:

  RSSFeed feed = executor.invoke(RSSFeed.class, new Invokable<RSSFeed>() { ... });

This only works if the type is an interface. A proxy for the interface is created around the Future object; any invocation on the proxy will invoke get() on the Future (that is, will block until the value is computed).


The behavior of the ParallelExecutor can be tuned with global configuration symbols.

Java constants for the configuration symbols are defined in IOCSymbols.


If true, the default, then the thread pool will operate. If false, then ParallelExecutor's implementation changes to invoke the Invokable immediately, not in a pooled thread. This is useful in environments, such as Google App Engine, that do not support the creation of threads and thread pools.


Minimum size of the thread pool. Defaults to 3.


Maximum number of threads (active or inactive) in the thread pool. Defaults to 20.


Time to keep waiting threads alive. Defaults to "1 m" (one minute).


Added in 5.3
The size of the task queue. When there are at least the core number of threads in the pool, tasks will be placed in the queue. If the queue is empty, more threads may be created (up to the maximum pool size). If the queue is full and all threads have been created, the task is rejected (and exception is thrown).

Defaults to 100.


  • No labels