Package io.vertx.core

## Class VertxOptions

- java.lang.Object
- - io.vertx.core.VertxOptions

-     public class VertxOptions
      extends Object

  Instances of this class are used to configure `Vertx` instances.
  Author:
    Tim Fox

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static long` | `DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL` | The default value of blocked thread check interval = 1000 ms.
    `static TimeUnit` | `DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT` | The default value of blocked thread check interval unit = `TimeUnit.MILLISECONDS`
    `static boolean` | `DEFAULT_DISABLE_TCCL` | The default value of thread context classloader disabling = `false`
    `static int` | `DEFAULT_EVENT_LOOP_POOL_SIZE` | The default number of event loop threads to be used = 2 * number of cores on the machine
    `static boolean` | `DEFAULT_HA_ENABLED` | The default value of HA enabled = false
    `static String` | `DEFAULT_HA_GROUP` | The default value of Ha group is "__DEFAULT__"
    `static int` | `DEFAULT_INTERNAL_BLOCKING_POOL_SIZE` | The default number of threads in the internal blocking pool (used by some internal operations) = 20
    `static long` | `DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME` | The default value of max event loop execute time = 2000000000 ns (2 seconds)
    `static TimeUnit` | `DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT` | The default value of max event loop execute time unit = `TimeUnit.NANOSECONDS`
    `static long` | `DEFAULT_MAX_WORKER_EXECUTE_TIME` | The default value of max worker execute time = 60000000000 ns (60 seconds)
    `static TimeUnit` | `DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT` | The default value of max worker execute time unit = `TimeUnit.NANOSECONDS`
    `static boolean` | `DEFAULT_PREFER_NATIVE_TRANSPORT` | The default value for preferring native transport = false
    `static int` | `DEFAULT_QUORUM_SIZE` | The default value of quorum size = 1
    `static boolean` | `DEFAULT_USE_DAEMON_THREAD` | Set default value to false for aligning with the old behavior By default, Vert.x threads are NOT daemons - we want them to prevent JVM exit so embedded user doesn't have to explicitly prevent JVM from exiting.
    `static TimeUnit` | `DEFAULT_WARNING_EXCEPTION_TIME_UNIT` | The default value of warning exception time unit = `TimeUnit.NANOSECONDS`
    `static int` | `DEFAULT_WORKER_POOL_SIZE` | The default number of threads in the worker pool = 20

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `VertxOptions()` | Default constructor
    `VertxOptions​(JsonObject json)` | Create an instance from a `JsonObject`
    `VertxOptions​(VertxOptions other)` | Copy constructor

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `AddressResolverOptions` | `getAddressResolverOptions()` |
    `long` | `getBlockedThreadCheckInterval()` | Get the value of blocked thread check period, in `blockedThreadCheckIntervalUnit`.
    `TimeUnit` | `getBlockedThreadCheckIntervalUnit()` |
    `boolean` | `getDisableTCCL()` |
    `EventBusOptions` | `getEventBusOptions()` |
    `int` | `getEventLoopPoolSize()` | Get the number of event loop threads to be used by the Vert.x instance.
    `FileSystemOptions` | `getFileSystemOptions()` |
    `String` | `getHAGroup()` | Get the HA group to be used when HA is enabled.
    `int` | `getInternalBlockingPoolSize()` | Get the value of internal blocking pool size.
    `long` | `getMaxEventLoopExecuteTime()` | Get the value of max event loop execute time, in `maxEventLoopExecuteTimeUnit`.
    `TimeUnit` | `getMaxEventLoopExecuteTimeUnit()` |
    `long` | `getMaxWorkerExecuteTime()` | Get the value of max worker execute time, in `maxWorkerExecuteTimeUnit`.
    `TimeUnit` | `getMaxWorkerExecuteTimeUnit()` |
    `MetricsOptions` | `getMetricsOptions()` |
    `boolean` | `getPreferNativeTransport()` |
    `int` | `getQuorumSize()` | Get the quorum size to be used when HA is enabled.
    `TracingOptions` | `getTracingOptions()` | If tracing is disabled, the value will be `null`.
    `Boolean` | `getUseDaemonThread()` | Returns whether we want to use daemon vertx thread.
    `long` | `getWarningExceptionTime()` | Get the threshold value above this, the blocked warning contains a stack trace.
    `TimeUnit` | `getWarningExceptionTimeUnit()` |
    `int` | `getWorkerPoolSize()` | Get the maximum number of worker threads to be used by the Vert.x instance.
    `boolean` | `isHAEnabled()` | Will HA be enabled on the Vert.x instance?
    `VertxOptions` | `setAddressResolverOptions​(AddressResolverOptions addressResolverOptions)` | Sets the address resolver configuration to configure resolving DNS servers, cache TTL, etc...
    `VertxOptions` | `setBlockedThreadCheckInterval​(long blockedThreadCheckInterval)` | Sets the value of blocked thread check period, in `blockedThreadCheckIntervalUnit`.
    `VertxOptions` | `setBlockedThreadCheckIntervalUnit​(TimeUnit blockedThreadCheckIntervalUnit)` | Set the time unit of `blockedThreadCheckInterval`.
    `VertxOptions` | `setDisableTCCL​(boolean disableTCCL)` | Configures whether Vert.x sets the `Context` classloader as the thread context classloader on actions executed on that `Context`.
    `VertxOptions` | `setEventBusOptions​(EventBusOptions options)` | Sets the event bus configuration to configure the host, port, ssl...
    `VertxOptions` | `setEventLoopPoolSize​(int eventLoopPoolSize)` | Set the number of event loop threads to be used by the Vert.x instance.
    `VertxOptions` | `setFileSystemOptions​(FileSystemOptions fileSystemOptions)` | Set the file system options
    `VertxOptions` | `setHAEnabled​(boolean haEnabled)` | Set whether HA will be enabled on the Vert.x instance.
    `VertxOptions` | `setHAGroup​(String haGroup)` | Set the HA group to be used when HA is enabled.
    `VertxOptions` | `setInternalBlockingPoolSize​(int internalBlockingPoolSize)` | Set the value of internal blocking pool size
    `VertxOptions` | `setMaxEventLoopExecuteTime​(long maxEventLoopExecuteTime)` | Sets the value of max event loop execute time, in `maxEventLoopExecuteTimeUnit`.
    `VertxOptions` | `setMaxEventLoopExecuteTimeUnit​(TimeUnit maxEventLoopExecuteTimeUnit)` | Set the time unit of `maxEventLoopExecuteTime`.
    `VertxOptions` | `setMaxWorkerExecuteTime​(long maxWorkerExecuteTime)` | Sets the value of max worker execute time, in `maxWorkerExecuteTimeUnit`.
    `VertxOptions` | `setMaxWorkerExecuteTimeUnit​(TimeUnit maxWorkerExecuteTimeUnit)` | Set the time unit of `maxWorkerExecuteTime`.
    `VertxOptions` | `setMetricsOptions​(MetricsOptions metrics)` | Set the metrics options
    `VertxOptions` | `setPreferNativeTransport​(boolean preferNativeTransport)` | Set whether to prefer the native transport to the NIO transport.
    `VertxOptions` | `setQuorumSize​(int quorumSize)` | Set the quorum size to be used when HA is enabled.
    `VertxOptions` | `setTracingOptions​(TracingOptions tracingOptions)` | Set the tracing options
    `VertxOptions` | `setUseDaemonThread​(Boolean daemon)` | Mark the vertx thread as daemon thread or user thread.
    `VertxOptions` | `setWarningExceptionTime​(long warningExceptionTime)` | Set the threshold value above this, the blocked warning contains a stack trace.
    `VertxOptions` | `setWarningExceptionTimeUnit​(TimeUnit warningExceptionTimeUnit)` | Set the time unit of `warningExceptionTime`.
    `VertxOptions` | `setWorkerPoolSize​(int workerPoolSize)` | Set the maximum number of worker threads to be used by the Vert.x instance.
    `JsonObject` | `toJson()` |
    `String` | `toString()` |

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### DEFAULT_EVENT_LOOP_POOL_SIZE

          public static final int DEFAULT_EVENT_LOOP_POOL_SIZE

      The default number of event loop threads to be used = 2 * number of cores on the machine

    - #### DEFAULT_WORKER_POOL_SIZE

          public static final int DEFAULT_WORKER_POOL_SIZE

      The default number of threads in the worker pool = 20
      See Also:
        Constant Field Values

    - #### DEFAULT_INTERNAL_BLOCKING_POOL_SIZE

          public static final int DEFAULT_INTERNAL_BLOCKING_POOL_SIZE

      The default number of threads in the internal blocking pool (used by some internal operations) = 20
      See Also:
        Constant Field Values

    - #### DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL

          public static final long DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL

      The default value of blocked thread check interval = 1000 ms.

    - #### DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT

          public static final TimeUnit DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT

      The default value of blocked thread check interval unit = `TimeUnit.MILLISECONDS`

    - #### DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME

          public static final long DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME

      The default value of max event loop execute time = 2000000000 ns (2 seconds)

    - #### DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT

          public static final TimeUnit DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT

      The default value of max event loop execute time unit = `TimeUnit.NANOSECONDS`

    - #### DEFAULT_MAX_WORKER_EXECUTE_TIME

          public static final long DEFAULT_MAX_WORKER_EXECUTE_TIME

      The default value of max worker execute time = 60000000000 ns (60 seconds)

    - #### DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT

          public static final TimeUnit DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT

      The default value of max worker execute time unit = `TimeUnit.NANOSECONDS`

    - #### DEFAULT_QUORUM_SIZE

          public static final int DEFAULT_QUORUM_SIZE

      The default value of quorum size = 1
      See Also:
        Constant Field Values

    - #### DEFAULT_HA_GROUP

          public static final String DEFAULT_HA_GROUP

      The default value of Ha group is "__DEFAULT__"
      See Also:
        Constant Field Values

    - #### DEFAULT_HA_ENABLED

          public static final boolean DEFAULT_HA_ENABLED

      The default value of HA enabled = false
      See Also:
        Constant Field Values

    - #### DEFAULT_PREFER_NATIVE_TRANSPORT

          public static final boolean DEFAULT_PREFER_NATIVE_TRANSPORT

      The default value for preferring native transport = false
      See Also:
        Constant Field Values

    - #### DEFAULT_WARNING_EXCEPTION_TIME_UNIT

          public static final TimeUnit DEFAULT_WARNING_EXCEPTION_TIME_UNIT

      The default value of warning exception time unit = `TimeUnit.NANOSECONDS`

    - #### DEFAULT_DISABLE_TCCL

          public static final boolean DEFAULT_DISABLE_TCCL

      The default value of thread context classloader disabling = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_USE_DAEMON_THREAD

          public static final boolean DEFAULT_USE_DAEMON_THREAD

      Set default value to false for aligning with the old behavior By default, Vert.x threads are NOT daemons - we want them to prevent JVM exit so embedded user doesn't have to explicitly prevent JVM from exiting.
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### VertxOptions

          public VertxOptions()

      Default constructor

    - #### VertxOptions

          public VertxOptions​(VertxOptions other)

      Copy constructor
      Parameters:
        `other` - The other `VertxOptions` to copy when creating this

    - #### VertxOptions

          public VertxOptions​(JsonObject json)

      Create an instance from a `JsonObject`
      Parameters:
        `json` - the JsonObject to create it from

  - ### Method Detail

    - #### getEventLoopPoolSize

          public int getEventLoopPoolSize()

      Get the number of event loop threads to be used by the Vert.x instance.
      Returns:
        the number of threads

    - #### setEventLoopPoolSize

          public VertxOptions setEventLoopPoolSize​(int eventLoopPoolSize)

      Set the number of event loop threads to be used by the Vert.x instance.
      Parameters:
        `eventLoopPoolSize` - the number of threads
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWorkerPoolSize

          public int getWorkerPoolSize()

      Get the maximum number of worker threads to be used by the Vert.x instance.

      Worker threads are used for running blocking code and worker verticles.

      Returns:
        the maximum number of worker threads

    - #### setWorkerPoolSize

          public VertxOptions setWorkerPoolSize​(int workerPoolSize)

      Set the maximum number of worker threads to be used by the Vert.x instance.
      Parameters:
        `workerPoolSize` - the number of threads
      Returns:
        a reference to this, so the API can be used fluently

    - #### getBlockedThreadCheckInterval

          public long getBlockedThreadCheckInterval()

      Get the value of blocked thread check period, in `blockedThreadCheckIntervalUnit`.

      This setting determines how often Vert.x will check whether event loop threads are executing for too long.

      The default value of `blockedThreadCheckIntervalUnit` is `TimeUnit.MILLISECONDS`.

      Returns:
        the value of blocked thread check period, in `blockedThreadCheckIntervalUnit`.

    - #### setBlockedThreadCheckInterval

          public VertxOptions setBlockedThreadCheckInterval​(long blockedThreadCheckInterval)

      Sets the value of blocked thread check period, in `blockedThreadCheckIntervalUnit`.

      The default value of `blockedThreadCheckIntervalUnit` is `TimeUnit.MILLISECONDS`

      Parameters:
        `blockedThreadCheckInterval` - the value of blocked thread check period, in `blockedThreadCheckIntervalUnit`.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxEventLoopExecuteTime

          public long getMaxEventLoopExecuteTime()

      Get the value of max event loop execute time, in `maxEventLoopExecuteTimeUnit`.

      Vert.x will automatically log a warning if it detects that event loop threads haven't returned within this time.

      This can be used to detect where the user is blocking an event loop thread, contrary to the Golden Rule of the holy Event Loop.

      The default value of `maxEventLoopExecuteTimeUnit` is `TimeUnit.NANOSECONDS`

      Returns:
        the value of max event loop execute time, in `maxEventLoopExecuteTimeUnit`.

    - #### setMaxEventLoopExecuteTime

          public VertxOptions setMaxEventLoopExecuteTime​(long maxEventLoopExecuteTime)

      Sets the value of max event loop execute time, in `maxEventLoopExecuteTimeUnit`.

      The default value of `maxEventLoopExecuteTimeUnit`is `TimeUnit.NANOSECONDS`

      Parameters:
        `maxEventLoopExecuteTime` - the value of max event loop execute time, in `maxEventLoopExecuteTimeUnit`.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWorkerExecuteTime

          public long getMaxWorkerExecuteTime()

      Get the value of max worker execute time, in `maxWorkerExecuteTimeUnit`.

      Vert.x will automatically log a warning if it detects that worker threads haven't returned within this time.

      This can be used to detect where the user is blocking a worker thread for too long. Although worker threads can be blocked longer than event loop threads, they shouldn't be blocked for long periods of time.

      The default value of `maxWorkerExecuteTimeUnit` is `TimeUnit.NANOSECONDS`

      Returns:
        The value of max worker execute time, in `maxWorkerExecuteTimeUnit`.

    - #### setMaxWorkerExecuteTime

          public VertxOptions setMaxWorkerExecuteTime​(long maxWorkerExecuteTime)

      Sets the value of max worker execute time, in `maxWorkerExecuteTimeUnit`.

      The default value of `maxWorkerExecuteTimeUnit` is `TimeUnit.NANOSECONDS`

      Parameters:
        `maxWorkerExecuteTime` - the value of max worker execute time, in `maxWorkerExecuteTimeUnit`.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getInternalBlockingPoolSize

          public int getInternalBlockingPoolSize()

      Get the value of internal blocking pool size.

      Vert.x maintains a pool for internal blocking operations

      Returns:
        the value of internal blocking pool size

    - #### setInternalBlockingPoolSize

          public VertxOptions setInternalBlockingPoolSize​(int internalBlockingPoolSize)

      Set the value of internal blocking pool size
      Parameters:
        `internalBlockingPoolSize` - the maximumn number of threads in the internal blocking pool
      Returns:
        a reference to this, so the API can be used fluently

    - #### isHAEnabled

          public boolean isHAEnabled()

      Will HA be enabled on the Vert.x instance?
      Returns:
        true if HA enabled, false otherwise

    - #### setHAEnabled

          public VertxOptions setHAEnabled​(boolean haEnabled)

      Set whether HA will be enabled on the Vert.x instance.
      Parameters:
        `haEnabled` - true if enabled, false if not.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getQuorumSize

          public int getQuorumSize()

      Get the quorum size to be used when HA is enabled.
      Returns:
        the quorum size

    - #### setQuorumSize

          public VertxOptions setQuorumSize​(int quorumSize)

      Set the quorum size to be used when HA is enabled.
      Parameters:
        `quorumSize` - the quorum size
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHAGroup

          public String getHAGroup()

      Get the HA group to be used when HA is enabled.
      Returns:
        the HA group

    - #### setHAGroup

          public VertxOptions setHAGroup​(String haGroup)

      Set the HA group to be used when HA is enabled.
      Parameters:
        `haGroup` - the HA group to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMetricsOptions

          public MetricsOptions getMetricsOptions()

      Returns:
        the metrics options

    - #### getFileSystemOptions

          public FileSystemOptions getFileSystemOptions()

      Returns:
        the file system options

    - #### setMetricsOptions

          public VertxOptions setMetricsOptions​(MetricsOptions metrics)

      Set the metrics options
      Parameters:
        `metrics` - the options
      Returns:
        a reference to this, so the API can be used fluently

    - #### setFileSystemOptions

          public VertxOptions setFileSystemOptions​(FileSystemOptions fileSystemOptions)

      Set the file system options
      Parameters:
        `fileSystemOptions` - the options
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWarningExceptionTime

          public long getWarningExceptionTime()

      Get the threshold value above this, the blocked warning contains a stack trace. in `warningExceptionTimeUnit`.

      The default value of `warningExceptionTimeUnit` is `TimeUnit.NANOSECONDS`

      Returns:
        the warning exception time threshold

    - #### setWarningExceptionTime

          public VertxOptions setWarningExceptionTime​(long warningExceptionTime)

      Set the threshold value above this, the blocked warning contains a stack trace. in `warningExceptionTimeUnit`. The default value of `warningExceptionTimeUnit` is `TimeUnit.NANOSECONDS`
      Parameters:
        `warningExceptionTime` -
      Returns:
        a reference to this, so the API can be used fluently

    - #### getEventBusOptions

          public EventBusOptions getEventBusOptions()

      Returns:
        the event bus option to configure the event bus communication (host, port, ssl...)

    - #### setEventBusOptions

          public VertxOptions setEventBusOptions​(EventBusOptions options)

      Sets the event bus configuration to configure the host, port, ssl...
      Parameters:
        `options` - the event bus options
      Returns:
        a reference to this, so the API can be used fluently

    - #### getAddressResolverOptions

          public AddressResolverOptions getAddressResolverOptions()

      Returns:
        the address resolver options to configure resolving DNS servers, cache TTL, etc...

    - #### setAddressResolverOptions

          public VertxOptions setAddressResolverOptions​(AddressResolverOptions addressResolverOptions)

      Sets the address resolver configuration to configure resolving DNS servers, cache TTL, etc...
      Parameters:
        `addressResolverOptions` - the address resolver options
      Returns:
        a reference to this, so the API can be used fluently

    - #### getPreferNativeTransport

          public boolean getPreferNativeTransport()

      Returns:
        whether to prefer the native transport to the NIO transport

    - #### setPreferNativeTransport

          public VertxOptions setPreferNativeTransport​(boolean preferNativeTransport)

      Set whether to prefer the native transport to the NIO transport.
      Parameters:
        `preferNativeTransport` - `true` to prefer the native transport
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxEventLoopExecuteTimeUnit

          public TimeUnit getMaxEventLoopExecuteTimeUnit()

      Returns:
        the time unit of `maxEventLoopExecuteTime`

    - #### setMaxEventLoopExecuteTimeUnit

          public VertxOptions setMaxEventLoopExecuteTimeUnit​(TimeUnit maxEventLoopExecuteTimeUnit)

      Set the time unit of `maxEventLoopExecuteTime`.
      Parameters:
        `maxEventLoopExecuteTimeUnit` - the time unit of `maxEventLoopExecuteTime`
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWorkerExecuteTimeUnit

          public TimeUnit getMaxWorkerExecuteTimeUnit()

      Returns:
        the time unit of `maxWorkerExecuteTime`

    - #### setMaxWorkerExecuteTimeUnit

          public VertxOptions setMaxWorkerExecuteTimeUnit​(TimeUnit maxWorkerExecuteTimeUnit)

      Set the time unit of `maxWorkerExecuteTime`.
      Parameters:
        `maxWorkerExecuteTimeUnit` - the time unit of `maxWorkerExecuteTime`
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWarningExceptionTimeUnit

          public TimeUnit getWarningExceptionTimeUnit()

      Returns:
        the time unit of `warningExceptionTime`

    - #### setWarningExceptionTimeUnit

          public VertxOptions setWarningExceptionTimeUnit​(TimeUnit warningExceptionTimeUnit)

      Set the time unit of `warningExceptionTime`.
      Parameters:
        `warningExceptionTimeUnit` - the time unit of `warningExceptionTime`
      Returns:
        a reference to this, so the API can be used fluently

    - #### getBlockedThreadCheckIntervalUnit

          public TimeUnit getBlockedThreadCheckIntervalUnit()

      Returns:
        the time unit of `blockedThreadCheckInterval`

    - #### setBlockedThreadCheckIntervalUnit

          public VertxOptions setBlockedThreadCheckIntervalUnit​(TimeUnit blockedThreadCheckIntervalUnit)

      Set the time unit of `blockedThreadCheckInterval`.
      Parameters:
        `blockedThreadCheckIntervalUnit` - the time unit of `warningExceptionTime`
      Returns:
        a reference to this, so the API can be used fluently

    - #### getTracingOptions

          public TracingOptions getTracingOptions()

      If tracing is disabled, the value will be `null`.
      Returns:
        the tracing options

    - #### setTracingOptions

          public VertxOptions setTracingOptions​(TracingOptions tracingOptions)

      Set the tracing options
      Parameters:
        `tracingOptions` - the options
      Returns:
        a reference to this, so the API can be used fluently

    - #### getDisableTCCL

          public boolean getDisableTCCL()

      Returns:
        whether Vert.x sets the `Context` classloader as the thread context classloader on actions executed on that `Context`

    - #### setDisableTCCL

          public VertxOptions setDisableTCCL​(boolean disableTCCL)

      Configures whether Vert.x sets the `Context` classloader as the thread context classloader on actions executed on that `Context`. When a `Context` is created the current thread classloader is captured and associated with this classloader. Likewise when a Verticle is created, the Verticle's `Context` classloader is set to the current thread classloader unless this classloader is overriden by `DeploymentOptions.getClassLoader()`. This setting overrides the (legacy) system property `vertx.disableTCCL` and provides control at the Vertx instance level.
      Parameters:
        `disableTCCL` - `true` to disable thread context classloader update by Vertx
      Returns:
        a reference to this, so the API can be used fluently

    - #### getUseDaemonThread

          public Boolean getUseDaemonThread()

      Returns whether we want to use daemon vertx thread.
      Returns:
        `true` means daemon, `false` means not daemon(user), `null` means do not change the daemon option of the created vertx thread.

    - #### setUseDaemonThread

          public VertxOptions setUseDaemonThread​(Boolean daemon)

      Mark the vertx thread as daemon thread or user thread.

      For keeping the old behavior, the default value is `false` instead of `null`.
      Parameters:
        `daemon` - `true` means daemon, `false` means not daemon(user), `null` means do not change the daemon option of the created vertx thread.

    - #### toJson

          public JsonObject toJson()

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`