public class VertxImpl extends Object implements VertxInternal, MetricsProvider
| Modifier and Type | Method and Description |
|---|---|
void |
addCloseHook(Closeable hook) |
AddressResolver |
addressResolver() |
BlockedThreadChecker |
blockedThreadChecker() |
boolean |
cancelTimer(long id)
Cancels the timer with the specified
id. |
void |
close()
Stop the the Vertx instance and release any resources held by it.
|
void |
close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.close() but the completionHandler will be called when the close is complete |
DatagramSocket |
createDatagramSocket()
Create a datagram socket using default options
|
DatagramSocket |
createDatagramSocket(DatagramSocketOptions options)
Create a datagram socket using the specified options
|
DnsClient |
createDnsClient()
Create a DNS client to connect to the DNS server configured by
VertxOptions.getAddressResolverOptions() |
DnsClient |
createDnsClient(DnsClientOptions options)
Create a DNS client to connect to a DNS server
|
DnsClient |
createDnsClient(int port,
String host)
Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)
|
EventLoopContext |
createEventLoopContext(io.netty.channel.EventLoop eventLoop,
WorkerPool workerPool,
ClassLoader tccl) |
EventLoopContext |
createEventLoopContext(String deploymentID,
WorkerPool workerPool,
JsonObject config,
ClassLoader tccl) |
HttpClient |
createHttpClient()
Create a HTTP/HTTPS client using default options
|
HttpClient |
createHttpClient(HttpClientOptions options)
Create a HTTP/HTTPS client using the specified options
|
HttpServer |
createHttpServer()
Create an HTTP/HTTPS server using default options
|
HttpServer |
createHttpServer(HttpServerOptions serverOptions)
Create an HTTP/HTTPS server using the specified options
|
NetClient |
createNetClient()
Create a TCP/SSL client using default options
|
NetClient |
createNetClient(NetClientOptions options)
Create a TCP/SSL client using the specified options
|
NetServer |
createNetServer()
Create a TCP/SSL server using default options
|
NetServer |
createNetServer(NetServerOptions options)
Create a TCP/SSL server using the specified options
|
io.vertx.core.impl.WorkerExecutorImpl |
createSharedWorkerExecutor(String name)
Like
Vertx.createSharedWorkerExecutor(String, int) but with the VertxOptions.setWorkerPoolSize(int) poolSize. |
io.vertx.core.impl.WorkerExecutorImpl |
createSharedWorkerExecutor(String name,
int poolSize)
Like
Vertx.createSharedWorkerExecutor(String, int, long) but with the VertxOptions.setMaxWorkerExecuteTime(long) maxExecuteTime. |
io.vertx.core.impl.WorkerExecutorImpl |
createSharedWorkerExecutor(String name,
int poolSize,
long maxExecuteTime)
Like
Vertx.createSharedWorkerExecutor(String, int, long, TimeUnit) but with the ns unit. |
io.vertx.core.impl.WorkerExecutorImpl |
createSharedWorkerExecutor(String name,
int poolSize,
long maxExecuteTime,
TimeUnit maxExecuteTimeUnit)
Create a named worker executor, the executor should be closed when it's not needed anymore to release
resources.
This method can be called mutiple times with the same
name. |
io.vertx.core.impl.ContextImpl |
createWorkerContext(boolean multiThreaded,
String deploymentID,
WorkerPool workerPool,
JsonObject config,
ClassLoader tccl) |
Set<String> |
deploymentIDs()
Return a Set of deployment IDs for the currently deployed deploymentIDs.
|
void |
deployVerticle(Class<? extends Verticle> verticleClass,
DeploymentOptions options)
Like
Vertx.deployVerticle(Verticle, DeploymentOptions) but Verticle instance is created by invoking the
default constructor of verticleClass. |
void |
deployVerticle(Class<? extends Verticle> verticleClass,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by
invoking the default constructor of verticleClass. |
void |
deployVerticle(String name)
Deploy a verticle instance given a name.
|
void |
deployVerticle(String name,
DeploymentOptions options)
Like
Vertx.deployVerticle(Verticle) but DeploymentOptions are provided to configure the
deployment. |
void |
deployVerticle(String name,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(String, Handler) but DeploymentOptions are provided to configure the
deployment. |
void |
deployVerticle(String name,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(String) but the completionHandler will be notified when the deployment is complete. |
void |
deployVerticle(Supplier<Verticle> verticleSupplier,
DeploymentOptions options)
Like
Vertx.deployVerticle(Verticle, DeploymentOptions) but Verticle instance is created by invoking the
verticleSupplier. |
void |
deployVerticle(Supplier<Verticle> verticleSupplier,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by
invoking the verticleSupplier. |
void |
deployVerticle(Verticle verticle)
Deploy a verticle instance that you have created yourself.
|
void |
deployVerticle(Verticle verticle,
DeploymentOptions options)
Like
Vertx.deployVerticle(Verticle) but DeploymentOptions are provided to configure the
deployment. |
void |
deployVerticle(Verticle verticle,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, Handler) but DeploymentOptions are provided to configure the
deployment. |
void |
deployVerticle(Verticle verticle,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle) but the completionHandler will be notified when the deployment is complete. |
EventBus |
eventBus()
Get the event bus object.
|
Handler<Throwable> |
exceptionHandler() |
Vertx |
exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context, set on Context.exceptionHandler(Handler) at creation. |
<T> void |
executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> asyncResultHandler)
Safely execute some blocking code.
|
<T> void |
executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> asyncResultHandler)
Like
Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
<T> void |
executeBlockingInternal(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx.executeBlocking(Handler, Handler) but using the internal worker thread pool. |
void |
failDuringFailover(boolean fail) |
void |
failoverCompleteHandler(FailoverCompleteHandler failoverCompleteHandler) |
FileSystem |
fileSystem()
Get the filesystem object.
|
io.netty.channel.EventLoopGroup |
getAcceptorEventLoopGroup() |
ClusterManager |
getClusterManager() |
io.vertx.core.impl.ContextImpl |
getContext()
Get the current context
|
Deployment |
getDeployment(String deploymentID) |
io.netty.channel.EventLoopGroup |
getEventLoopGroup() |
protected FileSystem |
getFileSystem() |
Metrics |
getMetrics()
Returns the metrics implementation.
|
String |
getNodeID() |
io.vertx.core.impl.ContextImpl |
getOrCreateContext()
Gets the current context, or creates one if there isn't one
|
ExecutorService |
getWorkerPool() |
HAManager |
haManager() |
boolean |
isClustered()
Is this Vert.x instance clustered?
|
boolean |
isKilled() |
boolean |
isMetricsEnabled()
Whether the metrics are enabled for this measured object
|
boolean |
isNativeTransportEnabled() |
long |
maxEventLoopExecTime() |
TimeUnit |
maxEventLoopExecTimeUnit() |
VertxMetrics |
metricsSPI() |
io.netty.resolver.AddressResolverGroup<InetSocketAddress> |
nettyAddressResolverGroup() |
io.netty.channel.EventLoopGroup |
nettyEventLoopGroup()
Return the Netty EventLoopGroup used by Vert.x
|
TimeoutStream |
periodicStream(long delay)
Returns a periodic timer as a read stream.
|
void |
registerVerticleFactory(VerticleFactory factory)
Register a
VerticleFactory that can be used for deploying Verticles based on an identifier. |
void |
removeCloseHook(Closeable hook) |
void |
resolveAddress(String hostname,
Handler<AsyncResult<InetAddress>> resultHandler)
Resolve an address (e.g.
|
File |
resolveFile(String fileName) |
void |
runOnContext(Handler<Void> task)
Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all
preceeding events have been handled.
|
long |
setPeriodic(long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds, at which point handler will be called with
the id of the timer. |
long |
setTimer(long delay,
Handler<Long> handler)
Set a one-shot timer to fire after
delay milliseconds, at which point handler will be called with
the id of the timer. |
SharedData |
sharedData()
Get the shared data object.
|
Map<ServerID,HttpServerImpl> |
sharedHttpServers() |
Map<ServerID,NetServerImpl> |
sharedNetServers() |
void |
simulateKill() |
TimeoutStream |
timerStream(long delay)
Returns a one-shot timer as a read stream.
|
Transport |
transport() |
void |
undeploy(String deploymentID)
Undeploy a verticle deployment.
|
void |
undeploy(String deploymentID,
Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.undeploy(String) but the completionHandler will be notified when the undeployment is complete. |
void |
unregisterVerticleFactory(VerticleFactory factory)
Unregister a
VerticleFactory |
Set<VerticleFactory> |
verticleFactories()
Return the Set of currently registered verticle factories.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitclusteredVertx, currentContext, vertx, vertxprotected FileSystem getFileSystem()
public long maxEventLoopExecTime()
maxEventLoopExecTime in interface VertxInternalpublic TimeUnit maxEventLoopExecTimeUnit()
maxEventLoopExecTimeUnit in interface VertxInternalpublic DatagramSocket createDatagramSocket(DatagramSocketOptions options)
VertxcreateDatagramSocket in interface Vertxoptions - the options to usepublic DatagramSocket createDatagramSocket()
VertxcreateDatagramSocket in interface Vertxpublic NetServer createNetServer(NetServerOptions options)
VertxcreateNetServer in interface Vertxoptions - the options to usepublic NetServer createNetServer()
VertxcreateNetServer in interface Vertxpublic NetClient createNetClient(NetClientOptions options)
VertxcreateNetClient in interface Vertxoptions - the options to usepublic NetClient createNetClient()
VertxcreateNetClient in interface Vertxpublic Transport transport()
transport in interface VertxInternalpublic boolean isNativeTransportEnabled()
isNativeTransportEnabled in interface Vertxpublic FileSystem fileSystem()
VertxfileSystem in interface Vertxpublic SharedData sharedData()
VertxsharedData in interface Vertxpublic HttpServer createHttpServer(HttpServerOptions serverOptions)
VertxcreateHttpServer in interface VertxserverOptions - the options to usepublic HttpServer createHttpServer()
VertxcreateHttpServer in interface Vertxpublic HttpClient createHttpClient(HttpClientOptions options)
VertxcreateHttpClient in interface Vertxoptions - the options to usepublic HttpClient createHttpClient()
VertxcreateHttpClient in interface Vertxpublic EventBus eventBus()
Vertxpublic long setPeriodic(long delay,
Handler<Long> handler)
Vertxdelay milliseconds, at which point handler will be called with
the id of the timer.setPeriodic in interface Vertxdelay - the delay in milliseconds, after which the timer will firehandler - the handler that will be called with the timer ID when the timer firespublic TimeoutStream periodicStream(long delay)
Vertxdelay milliseconds after
the ReadStream.handler(io.vertx.core.Handler<T>) has been called.periodicStream in interface Vertxdelay - the delay in milliseconds, after which the timer will firepublic long setTimer(long delay,
Handler<Long> handler)
Vertxdelay milliseconds, at which point handler will be called with
the id of the timer.public TimeoutStream timerStream(long delay)
Vertxdelay milliseconds after
the ReadStream.handler(io.vertx.core.Handler<T>) has been called.timerStream in interface Vertxdelay - the delay in milliseconds, after which the timer will firepublic void runOnContext(Handler<Void> task)
VertxrunOnContext in interface Vertxtask - - a handler representing the action to executepublic ExecutorService getWorkerPool()
getWorkerPool in interface VertxInternalpublic io.netty.channel.EventLoopGroup getEventLoopGroup()
getEventLoopGroup in interface VertxInternalpublic io.netty.channel.EventLoopGroup getAcceptorEventLoopGroup()
getAcceptorEventLoopGroup in interface VertxInternalpublic io.vertx.core.impl.ContextImpl getOrCreateContext()
VertxgetOrCreateContext in interface VertxInternalgetOrCreateContext in interface Vertxpublic Map<ServerID,HttpServerImpl> sharedHttpServers()
sharedHttpServers in interface VertxInternalpublic Map<ServerID,NetServerImpl> sharedNetServers()
sharedNetServers in interface VertxInternalpublic boolean isMetricsEnabled()
MeasuredisMetricsEnabled in interface Measuredtrue if metrics are enabledpublic Metrics getMetrics()
MetricsProvidergetMetrics in interface MetricsProviderpublic boolean cancelTimer(long id)
Vertxid.cancelTimer in interface Vertxid - The id of the timer to cancelpublic EventLoopContext createEventLoopContext(String deploymentID, WorkerPool workerPool, JsonObject config, ClassLoader tccl)
createEventLoopContext in interface VertxInternalpublic EventLoopContext createEventLoopContext(io.netty.channel.EventLoop eventLoop, WorkerPool workerPool, ClassLoader tccl)
createEventLoopContext in interface VertxInternalpublic io.vertx.core.impl.ContextImpl createWorkerContext(boolean multiThreaded,
String deploymentID,
WorkerPool workerPool,
JsonObject config,
ClassLoader tccl)
createWorkerContext in interface VertxInternalpublic DnsClient createDnsClient(int port, String host)
VertxcreateDnsClient in interface Vertxport - the porthost - the hostpublic DnsClient createDnsClient()
VertxVertxOptions.getAddressResolverOptions()
DNS client takes the first configured resolver address provided by DnsResolverProvider.nameServerAddresses()}
createDnsClient in interface Vertxpublic DnsClient createDnsClient(DnsClientOptions options)
VertxcreateDnsClient in interface Vertxoptions - the client optionspublic io.vertx.core.impl.ContextImpl getContext()
VertxInternalgetContext in interface VertxInternalpublic ClusterManager getClusterManager()
getClusterManager in interface VertxInternalpublic void close()
VertxThe instance cannot be used after it has been closed.
The actual close is asynchronous and may not complete until after the call has returned.
public void close(Handler<AsyncResult<Void>> completionHandler)
VertxVertx.close() but the completionHandler will be called when the close is completepublic void deployVerticle(Verticle verticle)
VertxVert.x will assign the verticle a context and start the verticle.
The actual deploy happens asynchronously and may not complete until after the call has returned.
deployVerticle in interface Vertxverticle - the verticle instance to deploy.public void deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)
VertxVertx.deployVerticle(Verticle) but the completionHandler will be notified when the deployment is complete.
If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.
This deployment ID can subsequently be used to undeploy the verticle.
deployVerticle in interface Vertxverticle - the verticle instance to deploycompletionHandler - a handler which will be notified when the deployment is completepublic void deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)
VertxVertx.deployVerticle(String) but the completionHandler will be notified when the deployment is complete.
If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.
This deployment ID can subsequently be used to undeploy the verticle.
deployVerticle in interface Vertxname - The identifiercompletionHandler - a handler which will be notified when the deployment is completepublic void deployVerticle(Verticle verticle, DeploymentOptions options)
VertxVertx.deployVerticle(Verticle) but DeploymentOptions are provided to configure the
deployment.deployVerticle in interface Vertxverticle - the verticle instance to deployoptions - the deployment options.public void deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options)
VertxVertx.deployVerticle(Verticle, DeploymentOptions) but Verticle instance is created by invoking the
default constructor of verticleClass.deployVerticle in interface Vertxpublic void deployVerticle(Supplier<Verticle> verticleSupplier, DeploymentOptions options)
VertxVertx.deployVerticle(Verticle, DeploymentOptions) but Verticle instance is created by invoking the
verticleSupplier.
The supplier will be invoked as many times as DeploymentOptions.getInstances().
It must not return the same instance twice.
Note that the supplier will be invoked on the caller thread.
deployVerticle in interface Vertxpublic void deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)
VertxVertx.deployVerticle(Verticle, Handler) but DeploymentOptions are provided to configure the
deployment.deployVerticle in interface Vertxverticle - the verticle instance to deployoptions - the deployment options.completionHandler - a handler which will be notified when the deployment is completepublic void deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)
VertxVertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by
invoking the default constructor of verticleClass.deployVerticle in interface Vertxpublic void deployVerticle(Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)
VertxVertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by
invoking the verticleSupplier.
The supplier will be invoked as many times as DeploymentOptions.getInstances().
It must not return the same instance twice.
Note that the supplier will be invoked on the caller thread.
deployVerticle in interface Vertxpublic void deployVerticle(String name)
Vertx
Given the name, Vert.x selects a VerticleFactory instance to use to instantiate the verticle.
For the rules on how factories are selected please consult the user manual.
deployVerticle in interface Vertxname - the name.public void deployVerticle(String name, DeploymentOptions options)
VertxVertx.deployVerticle(Verticle) but DeploymentOptions are provided to configure the
deployment.deployVerticle in interface Vertxname - the nameoptions - the deployment options.public void deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)
VertxVertx.deployVerticle(String, Handler) but DeploymentOptions are provided to configure the
deployment.deployVerticle in interface Vertxname - the nameoptions - the deployment options.completionHandler - a handler which will be notified when the deployment is completepublic String getNodeID()
getNodeID in interface VertxInternalpublic void undeploy(String deploymentID)
VertxThe actual undeployment happens asynchronously and may not complete until after the method has returned.
public void undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)
VertxVertx.undeploy(String) but the completionHandler will be notified when the undeployment is complete.public Set<String> deploymentIDs()
VertxdeploymentIDs in interface Vertxpublic void registerVerticleFactory(VerticleFactory factory)
VertxVerticleFactory that can be used for deploying Verticles based on an identifier.registerVerticleFactory in interface Vertxfactory - the factory to registerpublic void unregisterVerticleFactory(VerticleFactory factory)
VertxVerticleFactoryunregisterVerticleFactory in interface Vertxfactory - the factory to unregisterpublic Set<VerticleFactory> verticleFactories()
VertxverticleFactories in interface Vertxpublic <T> void executeBlockingInternal(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)
VertxInternalVertx.executeBlocking(Handler, Handler) but using the internal worker thread pool.executeBlockingInternal in interface VertxInternalpublic <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> asyncResultHandler)
Vertx
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 Promise.complete(T) or Promise.complete(Object) method, or the Promise.fail(java.lang.Throwable)
method if it failed.
In the blockingCodeHandler the current context remains the original context and therefore any task
scheduled in the blockingCodeHandler will be executed on the this context and not on the worker thread.
The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.
When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.
Long blocking operations should use a dedicated thread managed by the application, which can interact with
verticles using the event-bus or Context.runOnContext(Handler)
executeBlocking in interface VertxT - the type of the resultblockingCodeHandler - handler representing the blocking code to runordered - 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
guaranteesasyncResultHandler - handler that will be called when the blocking code is completepublic <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> asyncResultHandler)
VertxVertx.executeBlocking(Handler, boolean, Handler) called with ordered = true.executeBlocking in interface Vertxpublic boolean isClustered()
VertxisClustered in interface Vertxpublic io.netty.channel.EventLoopGroup nettyEventLoopGroup()
VertxnettyEventLoopGroup in interface Vertxpublic void simulateKill()
simulateKill in interface VertxInternalpublic Deployment getDeployment(String deploymentID)
getDeployment in interface VertxInternalpublic void failoverCompleteHandler(FailoverCompleteHandler failoverCompleteHandler)
failoverCompleteHandler in interface VertxInternalpublic boolean isKilled()
isKilled in interface VertxInternalpublic void failDuringFailover(boolean fail)
failDuringFailover in interface VertxInternalpublic VertxMetrics metricsSPI()
metricsSPI in interface VertxInternalpublic File resolveFile(String fileName)
resolveFile in interface VertxInternalpublic void resolveAddress(String hostname, Handler<AsyncResult<InetAddress>> resultHandler)
VertxInternalvertx.io into the first found A (IPv4) or AAAA (IPv6) record.resolveAddress in interface VertxInternalhostname - the hostname to resolveresultHandler - the result handlerpublic AddressResolver addressResolver()
addressResolver in interface VertxInternalpublic io.netty.resolver.AddressResolverGroup<InetSocketAddress> nettyAddressResolverGroup()
nettyAddressResolverGroup in interface VertxInternalAddressResolverGroup to use in a Netty Bootstrappublic BlockedThreadChecker blockedThreadChecker()
blockedThreadChecker in interface VertxInternalpublic HAManager haManager()
haManager in interface VertxInternalpublic io.vertx.core.impl.WorkerExecutorImpl createSharedWorkerExecutor(String name)
VertxVertx.createSharedWorkerExecutor(String, int) but with the VertxOptions.setWorkerPoolSize(int) poolSize.createSharedWorkerExecutor in interface VertxInternalcreateSharedWorkerExecutor in interface Vertxpublic io.vertx.core.impl.WorkerExecutorImpl createSharedWorkerExecutor(String name, int poolSize)
VertxVertx.createSharedWorkerExecutor(String, int, long) but with the VertxOptions.setMaxWorkerExecuteTime(long) maxExecuteTime.createSharedWorkerExecutor in interface VertxInternalcreateSharedWorkerExecutor in interface Vertxpublic io.vertx.core.impl.WorkerExecutorImpl createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime)
VertxVertx.createSharedWorkerExecutor(String, int, long, TimeUnit) but with the ns unit.createSharedWorkerExecutor in interface VertxInternalcreateSharedWorkerExecutor in interface Vertxpublic io.vertx.core.impl.WorkerExecutorImpl createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime, TimeUnit maxExecuteTimeUnit)
Vertxname. Executors with the same name will share
the same worker pool. The worker pool size , max execute time and unit of max execute time are set when the worker pool is created and
won't change after.
The worker pool is released when all the WorkerExecutor sharing the same name are closed.
createSharedWorkerExecutor in interface VertxInternalcreateSharedWorkerExecutor in interface Vertxname - the name of the worker executorpoolSize - the size of the poolmaxExecuteTime - the value of max worker execute timemaxExecuteTimeUnit - the value of unit of max worker execute timepublic Vertx exceptionHandler(Handler<Throwable> handler)
VertxContext, set on Context.exceptionHandler(Handler) at creation.exceptionHandler in interface Vertxhandler - the exception handlerpublic Handler<Throwable> exceptionHandler()
exceptionHandler in interface Vertxpublic void addCloseHook(Closeable hook)
addCloseHook in interface VertxInternalpublic void removeCloseHook(Closeable hook)
removeCloseHook in interface VertxInternalCopyright © 2020. All rights reserved.