Identifier for all available thread context types which are not specified individually under cleared, propagated, or unchanged.

When using this constant, be aware that bringing in a new context provider or updating levels of an existing context provider might change the set of available thread context types.

See Also

ManagedExecutor.Builder#cleared, ManagedExecutor.Builder#propagated, ThreadContext.Builder

Identifier for application context. Application context controls the application component that is associated with a thread. For Jakarta/Java EE applications, application context includes the thread context class loader as well as the java:comp, java:module, and java:app name spaces of the application. An empty/default application context means that the thread is not associated with any application.

See Also

ManagedExecutor.Builder#cleared, ManagedExecutor.Builder#propagated, ThreadContext.Builder

Identifier for CDI context. CDI context controls the availability of CDI scopes. An empty/default CDI context means that the thread does not have access to the scope of the session, request, and so forth that created the contextualized action. For example, consider the following @RequestScoped resource:

   @RequestScoped
   public class MyRequestScopedBean {
       public String getState() {
         // returns some request-specific information to the caller
       }
   }
   

   ManagedExecutor exec = ManagedExecutor.builder()
       .propagated(ThreadContext.CDI, ThreadContext.APPLICATION)
       .build();

   @Inject
   MyRequestScopedBean requestBean;

   @GET
   public void foo() {
       exec.supplyAsync(() -> {
           String state = reqBean.getState();
           // do some work with the request state
       }).thenApply(more -> {
           // request state also available in future stages
       });
   }
   

See Also

ManagedExecutor.Builder#cleared, ManagedExecutor.Builder#propagated, ThreadContext.Builder

An empty array of thread context.

This is provided as a convenience for code that wishes to be more explicit. For example, you can specify builder.propagated(ThreadContext.NONE) rather than builder.propagated(new String[0]) or builder.propagated(), all of which have the same meaning.

When using MicroProfile Config to specify defaults, the value None indicates an empty array. For example,

mp.context.ThreadContext.unchanged=None

mp.context.ManagedExecutor.propagated=None

Identifier for security context. Security context controls the credentials that are associated with the thread. An empty/default security context means that the thread is unauthenticated.

See Also

ManagedExecutor.Builder#cleared, ManagedExecutor.Builder#propagated, ThreadContext.Builder

Identifier for transaction context. Transaction context controls the active transaction scope that is associated with the thread. Implementations are not expected to propagate transaction context across threads. Instead, the concept of transaction context is provided for its cleared context, which means the active transaction on the thread is suspended such that a new transaction can be started if so desired. In most cases, the most desirable behavior will be to leave transaction context defaulted to cleared (suspended), in order to prevent dependent actions and tasks from accidentally enlisting in transactions that are on the threads where they happen to run.

See Also

ManagedExecutor.Builder#cleared, ManagedExecutor.Builder#propagated, ThreadContext.Builder

Creates a new Builder instance.

Returns:ThreadContext.Builder

a new Builder instance.

Wraps a Callable with context that is captured from the thread that invokes contextualCallable.

When call is invoked on the proxy instance, context is first established on the thread that will run the call method, then the call method of the provided Callable is invoked. Finally, the previous context is restored on the thread, and the result of the Callable is returned to the invoker.

Parameters

<R>

callable result type.

callable:Callable<R>

instance to contextualize.

Returns:Callable<R>

contextualized proxy instance that wraps execution of the call method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized Callable is supplied to this method.

Wraps a BiConsumer with context that is captured from the thread that invokes contextualConsumer.

When accept is invoked on the proxy instance, context is first established on the thread that will run the accept method, then the accept method of the provided BiConsumer is invoked. Finally, the previous context is restored on the thread, and control is returned to the invoker.

Parameters

<T>

type of first parameter to consumer.

<U>

type of second parameter to consumer.

consumer:BiConsumer<T, U>

instance to contextualize.

Returns:BiConsumer<T, U>

contextualized proxy instance that wraps execution of the accept method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized BiConsumer is supplied to this method.

Wraps a Consumer with context that is captured from the thread that invokes contextualConsumer.

When accept is invoked on the proxy instance, context is first established on the thread that will run the accept method, then the accept method of the provided Consumer is invoked. Finally, the previous context is restored on the thread, and control is returned to the invoker.

Parameters

<T>

type of parameter to consumer.

consumer:Consumer<T>

instance to contextualize.

Returns:Consumer<T>

contextualized proxy instance that wraps execution of the accept method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized Consumer is supplied to this method.

Wraps a BiFunction with context that is captured from the thread that invokes contextualFunction.

When apply is invoked on the proxy instance, context is first established on the thread that will run the apply method, then the apply method of the provided BiFunction is invoked. Finally, the previous context is restored on the thread, and the result of the BiFunction is returned to the invoker.

Parameters

<T>

type of first parameter to function.

<U>

type of second parameter to function.

<R>

function result type.

function:BiFunction<T, U, R>

instance to contextualize.

Returns:BiFunction<T, U, R>

contextualized proxy instance that wraps execution of the apply method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized BiFunction is supplied to this method.

Wraps a Function with context that is captured from the thread that invokes contextualFunction.

When apply is invoked on the proxy instance, context is first established on the thread that will run the apply method, then the apply method of the provided Function is invoked. Finally, the previous context is restored on the thread, and the result of the Function is returned to the invoker.

Parameters

<T>

type of parameter to function.

<R>

function result type.

function:Function<T, R>

instance to contextualize.

Returns:Function<T, R>

contextualized proxy instance that wraps execution of the apply method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized Function is supplied to this method.

Wraps a Runnable with context that is captured from the thread that invokes ContextualRunnable.

When run is invoked on the proxy instance, context is first established on the thread that will run the run method, then the run method of the provided Runnable is invoked. Finally, the previous context is restored on the thread, and control is returned to the invoker.

Parameters

runnable:Runnable

instance to contextualize.

Returns:Runnable

contextualized proxy instance that wraps execution of the run method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized Runnable is supplied to this method.

Wraps a Supplier with context captured from the thread that invokes contextualSupplier.

When supply is invoked on the proxy instance, context is first established on the thread that will run the supply method, then the supply method of the provided Supplier is invoked. Finally, the previous context is restored on the thread, and the result of the Supplier is returned to the invoker.

Parameters

<R>

supplier result type.

supplier:Supplier<R>

instance to contextualize.

Returns:Supplier<R>

contextualized proxy instance that wraps execution of the supply method with context.

Exceptions

IllegalArgumentException:

if an already-contextualized Supplier is supplied to this method.

Creates an Executorthat runs tasks on the same thread from which executeis invoked but with context that is captured from the thread that invokes currentContextExecutor.

Example usage:

Executor contextSnapshot = threadContext.currentContextExecutor();
...
// from another thread, or after thread context has changed,
contextSnapshot.execute(() -> obj.doSomethingThatNeedsContext());
contextSnapshot.execute(() -> doSomethingElseThatNeedsContext(x, y));

The returned Executor must raise IllegalArgumentException if an already-contextualized Runnable is supplied to its execute method.

Returns:Executor

an executor that wraps the execute method with context.

Returns a new CompletableFuture that is completed by the completion of the specified stage.

The new completable future will use the same default executor as this ThreadContext, which can be a ManagedExecutor if this ThreadContext was obtained by ManagedExecutor#getThreadContext() or the default executor service if provided by the platform (which can be done via ContextManager.Builder#withDefaultExecutorService(ExecutorService)), or otherwise have no default executor.

If this thread context has no default executor, the new stage and all dependent stages created from it, and so forth, have no default asynchronous execution facility and must raise java.lang.UnsupportedOperationException for all *Async methods that do not specify an executor. For example, thenRunAsync(Runnable).

When dependent stages are created from the new completable future, thread context is captured and/or cleared as described in the documentation of the ManagedExecutor class, except that this ThreadContext instance takes the place of the default asynchronous execution facility in supplying the configuration of cleared/propagated context types. This guarantees that the action performed by each stage always runs under the thread context of the code that creates the stage, unless the user explicitly overrides by supplying a pre-contextualized action.

Invocation of this method does not impact thread context propagation for the supplied completable future or any dependent stages created from it, other than the new dependent completable future that is created by this method.

Parameters

<T>

completable future result type.

stage:CompletableFuture<T>

a completable future whose completion triggers completion of the new completable future that is created by this method.

Returns:CompletableFuture<T>

the new completable future.

Returns a new CompletionStage that is completed by the completion of the specified stage.

The new completion stage will use the same default executor as this ThreadContext, which can be a ManagedExecutor if this ThreadContext was obtained by ManagedExecutor#getThreadContext() or the default executor service if provided by the platform (which can be done via ContextManager.Builder#withDefaultExecutorService(ExecutorService)), or otherwise have no default executor.

If this thread context has no default executor, the new stage and all dependent stages created from it, and so forth, have no default asynchronous execution facility and must raise java.lang.UnsupportedOperationException for all *Async methods that do not specify an executor. For example, thenRunAsync(Runnable).

When dependent stages are created from the new completion stage, thread context is captured and/or cleared as described in the documentation of the ManagedExecutor class, except that this ThreadContext instance takes the place of the default asynchronous execution facility in supplying the configuration of cleared/propagated context types. This guarantees that the action performed by each stage always runs under the thread context of the code that creates the stage, unless the user explicitly overrides by supplying a pre-contextualized action.

Invocation of this method does not impact thread context propagation for the supplied stage or any dependent stages created from it, other than the new dependent completion stage that is created by this method.

Parameters

<T>

completion stage result type.

stage:CompletionStage<T>

a completion stage whose completion triggers completion of the new stage that is created by this method.

Returns:CompletionStage<T>

the new completion stage.