The execution context of a handler execution.

When Vert.x provides an event to a handler or calls the start or stop methods of a io.vertx.core.Verticle, the execution is associated with a Context.

Usually a context is an event-loop context and is tied to a specific event loop thread. So executions for that context always occur on that exact same event loop thread.

In the case of worker verticles and running inline blocking code a worker context will be associated with the execution which will use a thread from the worker thread pool.

When a handler is set by a thread associated with a specific context, the Vert.x will guarantee that when that handler is executed, that execution will be associated with the same context.

If a handler is set by a thread not associated with a context (i.e. a non Vert.x thread). Then a new context will be created for that handler.

In other words, a context is propagated.

This means that when a verticle is deployed, any handlers it sets will be associated with the same context - the context of the verticle.

This means (in the case of a standard verticle) that the verticle code will always be executed with the exact same thread, so you don't have to worry about multi-threaded acccess to the verticle state and you can code your application as single threaded.

This class also allows arbitrary data to be put and get on the context so it can be shared easily amongst different handlers of, for example, a verticle instance.

This class also provides runOnContext which allows an action to be executed asynchronously using the same context.

  • Context
    • Basic
      • Identifiable
      • Object
        • Anything

no subtypes hierarchy

Initializer
Context(Context unknown)
Inherited Attributes
Attributes inherited from: Object
hash, string
Methods
configshared default Object? config()

If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.

deploymentIDshared default String deploymentID()

If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.

exceptionHandlershared default Context exceptionHandler(Anything(Throwable)? handler)

Set an exception handler called when the context runs an action throwing an uncaught throwable.

When this handler is called, currentContext will return this context.

Parameters:
  • handler

    the exception handler

executeBlockingshared default void executeBlocking<T>(Anything(Future<T?>) blockingCodeHandler, Anything(Throwable|T?) resultHandler)

Invoke executeBlocking with order = true.

Parameters:
  • blockingCodeHandler

    handler representing the blocking code to run

  • resultHandler

    handler that will be called when the blocking code is complete

executeBlockingshared default void executeBlocking<T>(Anything(Future<T?>) blockingCodeHandler, Boolean ordered, Anything(Throwable|T?) resultHandler)

Safely execute some blocking code.

Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.

When the code is complete the handler resultHandler will be called with the result on the original context (e.g. on the original event loop of the caller).

A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the complete or complete method, or the fail method if it failed.

Parameters:
  • blockingCodeHandler

    handler representing the blocking code to run

  • ordered

    if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees

  • resultHandler

    handler that will be called when the blocking code is complete

getshared default T? get<T>(String key)

Get some data from the context.

Parameters:
  • key

    the key of the data

getInstanceCountshared default Integer getInstanceCount()
isEventLoopContextshared default Boolean isEventLoopContext()

Is the current context an event loop context?

NOTE! when running blocking code using executeBlocking from a standard (not worker) verticle, the context will still an event loop context and this will return true.

isMultiThreadedWorkerContextshared default Boolean isMultiThreadedWorkerContext()

Is the current context a multi-threaded worker context?

isWorkerContextshared default Boolean isWorkerContext()

Is the current context a worker context?

NOTE! when running blocking code using executeBlocking from a standard (not worker) verticle, the context will still an event loop context and this will return false.

ownershared default Vertx owner()
processArgsshared default List<String> processArgs()

The process args

putshared default void put(String key, Object? value)

Put some data in the context.

This can be used to share data between different handlers that share a context

Parameters:
  • key

    the key of the data

  • value

    the data

removeshared default Boolean remove(String key)

Remove some data from the context.

Parameters:
  • key

    the key to remove

runOnContextshared default void runOnContext(Anything() action)

Run the specified action asynchronously on the same context, some time after the current execution has completed.

Parameters:
  • action

    the action to run

Inherited Methods
Methods inherited from: Object
equals