org.jgroups.blocks.executor

## Class ExecutionCompletionService<V>

- java.lang.Object
- - org.jgroups.blocks.executor.ExecutionCompletionService<V>

All Implemented Interfaces:
  java.util.concurrent.CompletionService<V>

    public class ExecutionCompletionService<V>
    extends java.lang.Object
    implements java.util.concurrent.CompletionService<V>

A `CompletionService` that uses a supplied `ExecutionService` to execute tasks. This class arranges that submitted tasks are, upon completion, placed on a queue accessible using `take`. The class is lightweight enough to be suitable for transient use when processing groups of tasks.

This class must be used instead of a `ExecutorCompletionService` provided from java.util.concurrent package. The `ExecutorCompletionService` may not be used since it requires the use of a non serializable RunnableFuture object. Since a ExecutionService may only be used with serializable request objects, this class must be used instead.

### Nested Class Summary

Nested Classes
`protected class` `ExecutionCompletionService.QueueingListener`

### Field Summary

Fields
`protected java.util.concurrent.BlockingQueue<NotifyingFuture<V>>` `completionQueue`
`protected ExecutionService` `executor`
`protected ExecutionCompletionService.QueueingListener` `listener`

### Constructor Summary

Constructors
`` `ExecutionCompletionService(ExecutionService executor)` Creates an ExecutorCompletionService using the supplied executor for base task execution and a `LinkedBlockingQueue` as a completion queue.
`` `ExecutionCompletionService(ExecutionService executor, java.util.concurrent.BlockingQueue<NotifyingFuture<V>> completionQueue)` Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.
`protected` `ExecutionCompletionService(ExecutionService executor, java.util.concurrent.BlockingQueue<NotifyingFuture<V>> completionQueue, ExecutionCompletionService.QueueingListener listener)` This constructor is here if someone wants to override this class and provide their own QueueingListener to possibly listen in on futures being finished

### Method Summary

Methods
`NotifyingFuture<V>` `poll()`
`NotifyingFuture<V>` `poll(long timeout, java.util.concurrent.TimeUnit unit)`
`java.util.concurrent.Future<V>` `submit(java.util.concurrent.Callable<V> task)`
`java.util.concurrent.Future<V>` `submit(java.lang.Runnable task, V result)`
`NotifyingFuture<V>` `take()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### executor

    protected final ExecutionService executor

#### completionQueue

    protected final java.util.concurrent.BlockingQueue<NotifyingFuture<V>> completionQueue

#### listener

    protected final ExecutionCompletionService.QueueingListener listener

### Constructor Detail

#### ExecutionCompletionService

    public ExecutionCompletionService(ExecutionService executor)

Creates an ExecutorCompletionService using the supplied executor for base task execution and a `LinkedBlockingQueue` as a completion queue.

Parameters:
  `executor` - the executor to use
Throws:
  `java.lang.NullPointerException` - if executor is `null`

#### ExecutionCompletionService

    public ExecutionCompletionService(ExecutionService executor,
                              java.util.concurrent.BlockingQueue<NotifyingFuture<V>> completionQueue)

Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.

Parameters:
  `executor` - the executor to use
  `completionQueue` - the queue to use as the completion queue normally one dedicated for use by this service
Throws:
  `java.lang.NullPointerException` - if executor is `null`

#### ExecutionCompletionService

    protected ExecutionCompletionService(ExecutionService executor,
                              java.util.concurrent.BlockingQueue<NotifyingFuture<V>> completionQueue,
                              ExecutionCompletionService.QueueingListener listener)

This constructor is here if someone wants to override this class and provide their own QueueingListener to possibly listen in on futures being finished

Parameters:
  `executor` - the executor to use
  `completionQueue` - the queue to use as the completion queue normally one dedicated for use by this service
  `listener` - the listener to notify. To work properly this listner should at minimum call the super.futureDone or else this completion service may not work correctly.
Throws:
  `java.lang.NullPointerException` - if executor is `null`

### Method Detail

#### submit

    public java.util.concurrent.Future<V> submit(java.util.concurrent.Callable<V> task)

This future object may not be used as a NotifyingFuture. That is because internally this class sets the listener to provide ability to add to the queue.

Specified by:
  `submit` in interface `java.util.concurrent.CompletionService<V>`

#### submit

    public java.util.concurrent.Future<V> submit(java.lang.Runnable task,
                                        V result)

This future object may not be used as a NotifyingFuture. That is because internally this class sets the listener to provide ability to add to the queue.

Specified by:
  `submit` in interface `java.util.concurrent.CompletionService<V>`

#### take

    public NotifyingFuture<V> take()
                            throws java.lang.InterruptedException

This future may safely be used as a NotifyingFuture if desired. This is because if it tries to set a listener it will be called immediately since the task has already been completed.

Specified by:
  `take` in interface `java.util.concurrent.CompletionService<V>`
Throws:
  `java.lang.InterruptedException`

#### poll

    public NotifyingFuture<V> poll()

This future may safely be used as a NotifyingFuture if desired. This is because if it tries to set a listener it will be called immediately since the task has already been completed.

Specified by:
  `poll` in interface `java.util.concurrent.CompletionService<V>`

#### poll

    public NotifyingFuture<V> poll(long timeout,
                          java.util.concurrent.TimeUnit unit)
                            throws java.lang.InterruptedException

This future may safely be used as a NotifyingFuture if desired. This is because if it tries to set a listener it will be called immediately since the task has already been completed.

Specified by:
  `poll` in interface `java.util.concurrent.CompletionService<V>`
Throws:
  `java.lang.InterruptedException`