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
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `ExecutionCompletionService.QueueingListener`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected java.util.concurrent.BlockingQueue<NotifyingFuture<V>>` | `completionQueue`
    `protected ExecutionService` | `executor`
    `protected ExecutionCompletionService.QueueingListener` | `listener`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `` | `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
    Modifier and Type | Method and Description
    --- | ---
    `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`

Copyright © 1998-2009 Bela Ban / Red Hat. All Rights Reserved.