Package org.eclipse.jetty.util.thread

Enum Class Invocable.InvocationType

java.lang.Object
java.lang.Enum<Invocable.InvocationType>
org.eclipse.jetty.util.thread.Invocable.InvocationType
All Implemented Interfaces:
Serializable, Comparable<Invocable.InvocationType>, Constable
Enclosing interface:
Invocable
public static enum Invocable.InvocationType extends Enum<Invocable.InvocationType>

The behavior of an Invocable task when it is called.

Typically, tasks such as Runnables or Callbacks declare their invocation type; this information is then used by the code that should invoke the Runnable or Callback to decide whether to invoke it directly, or submit it to a thread pool to be invoked by a different thread.

  • Enum Constant Details

    • BLOCKING

      public static final Invocable.InvocationType BLOCKING

      Invoking the task may block the invoker thread, and the invocation may be performed immediately (possibly blocking the invoker thread) or deferred to a later time, for example by submitting the task to a thread pool.

      This invocation type is suitable for tasks that call application code, for example to process an HTTP request.

    • NON_BLOCKING

      public static final Invocable.InvocationType NON_BLOCKING

      Invoking the task does not block the invoker thread, and the invocation must be performed immediately in the invoker thread.

      This invocation type is suitable for tasks that can not be deferred and is guaranteed to never block the invoker thread.

    • EITHER

      public static final Invocable.InvocationType EITHER

      Invoking the task may act either as a BLOCKING task if invoked directly; or as a NON_BLOCKING task if invoked via Invocable.invokeNonBlocking(Runnable). The implementation of the task must check Invocable.isNonBlockingInvocation() to determine how it was called.

      This invocation type is suitable for tasks that have multiple subtasks, some of which that cannot be deferred mixed with other subtasks that can be. An invoker which has an EITHER task must call it immediately, either directly, so that it may block; or via Invocable.invokeNonBlocking(Runnable) so that it may not. The invoker cannot defer the task execution, and specifically it must not queue the EITHER task in a thread pool.

      See the AdaptiveExecutionStrategy for an example of both an invoker of EITHER tasks, and as an implementation of an EITHER task, when used in a chain of ExecutionStrategys.

  • Method Details

    • values

      public static Invocable.InvocationType[] values()
      Returns an array containing the constants of this enum class, in the order they are declared.
      Returns:
      an array containing the constants of this enum class, in the order they are declared

    • valueOf

      public static Invocable.InvocationType valueOf(String name)
      Returns the enum constant of this class with the specified name. The string must match exactly an identifier used to declare an enum constant in this class. (Extraneous whitespace characters are not permitted.)
      Parameters:
      name - the name of the enum constant to be returned.
      Returns:
      the enum constant with the specified name
      Throws:
      IllegalArgumentException - if this enum class has no constant with the specified name
      NullPointerException - if the argument is null

    • runWithoutBlocking

      public abstract void runWithoutBlocking(Runnable task, Executor executor)
      Run or Execute the task according to the InvocationType without blocking the caller:
      NON_BLOCKING
      The task is run directly
      BLOCKING
      The task is executed by the passed executor
      EITHER
      The task is invoked via Invocable.invokeNonBlocking(Runnable)
      Parameters:
      task - The task to run
      executor - The executor to use if necessary