Package com.rabbitmq.client.impl.nio

Class NioParams

java.lang.Object
com.rabbitmq.client.impl.nio.NioParams
public class NioParams extends Object
Parameters used to configure the NIO mode of a ConnectionFactory.
Since:
4.0.0

  • Constructor Details

    • NioParams

      public NioParams()

    • NioParams

      public NioParams(NioParams nioParams)

  • Method Details

    • enableHostnameVerification

      public NioParams enableHostnameVerification()
      Enable server hostname verification for TLS connections.
      Returns:
      this NioParams instance
      See Also:

    • getReadByteBufferSize

      public int getReadByteBufferSize()

    • setReadByteBufferSize

      public NioParams setReadByteBufferSize(int readByteBufferSize)
      Sets the size in byte of the read ByteBuffer used in the NIO loop. Default is 32768.

      This parameter isn't used when using SSL/TLS, where ByteBuffer size is set up according to the SSLSession packet size.

      Parameters:
      readByteBufferSize - size of the ByteBuffer for inbound data
      Returns:
      this NioParams instance

    • getWriteByteBufferSize

      public int getWriteByteBufferSize()

    • setWriteByteBufferSize

      public NioParams setWriteByteBufferSize(int writeByteBufferSize)
      Sets the size in byte of the write ByteBuffer used in the NIO loop. Default is 32768.

      This parameter isn't used when using SSL/TLS, where ByteBuffer size is set up according to the SSLSession packet size.

      Parameters:
      writeByteBufferSize - size of the ByteBuffer used for outbound data
      Returns:
      this NioParams instance

    • getNbIoThreads

      public int getNbIoThreads()

    • setNbIoThreads

      public NioParams setNbIoThreads(int nbIoThreads)
      Sets the max number of threads/tasks used for NIO. Default is 1. Set this number according to the number of simultaneous connections and their activity. Threads/tasks are created as necessary (e.g. with 10 threads, when 10 connections have been created). Once a connection is created, it's assigned to a thread/task and all its IO activity is handled by this thread/task.

      When idle for a few seconds (i.e. without any connection to perform IO for), a thread/task stops and is recreated if necessary.

      Parameters:
      nbIoThreads -
      Returns:
      this NioParams instance

    • getWriteEnqueuingTimeoutInMs

      public int getWriteEnqueuingTimeoutInMs()

    • setWriteEnqueuingTimeoutInMs

      public NioParams setWriteEnqueuingTimeoutInMs(int writeEnqueuingTimeoutInMs)
      Sets the timeout for queuing outbound frames. Default is 10,000 ms. Every requests to the server is divided into frames that are then queued in a BlockingQueue before being sent on the network by a IO thread.

      If the IO thread cannot cope with the frames dispatch, the BlockingQueue gets filled up and blocks (blocking the calling thread by the same occasion). This timeout is the time the BlockingQueue will wait before rejecting the outbound frame. The calling thread will then received an exception.

      The appropriate value depends on the application scenarios: rate of outbound data (published messages, acknowledgment, etc), network speed...

      Parameters:
      writeEnqueuingTimeoutInMs -
      Returns:
      this NioParams instance
      See Also:

    • getNioExecutor

      public ExecutorService getNioExecutor()

    • setNioExecutor

      public NioParams setNioExecutor(ExecutorService nioExecutor)
      Sets the ExecutorService to use for NIO threads/tasks. Default is to use the thread factory.

      The ExecutorService should be able to run the number of requested IO threads, plus a few more, as it's also used to dispatch the shutdown of connections.

      Connection shutdown can also be handled by a dedicated ExecutorService, see setConnectionShutdownExecutor(ExecutorService).

      It's developer's responsibility to shut down the executor when it is no longer needed.

      The thread factory isn't used if an executor service is set up.

      Parameters:
      nioExecutor - ExecutorService used for IO threads and connection shutdown
      Returns:
      this NioParams instance
      See Also:

    • getThreadFactory

      public ThreadFactory getThreadFactory()

    • setThreadFactory

      public NioParams setThreadFactory(ThreadFactory threadFactory)
      Sets the ThreadFactory to use for NIO threads/tasks. Default is to use the ConnectionFactory's ThreadFactory.

      The ThreadFactory is used to spawn the IO threads and dispatch the shutdown of connections.

      Parameters:
      threadFactory - ThreadFactory used for IO threads and connection shutdown
      Returns:
      this NioParams instance
      See Also:

    • getWriteQueueCapacity

      public int getWriteQueueCapacity()

    • setWriteQueueCapacity

      public NioParams setWriteQueueCapacity(int writeQueueCapacity)
      Set the capacity of the queue used for outbound frames. Default capacity is 10,000.
      Parameters:
      writeQueueCapacity -
      Returns:
      this NioParams instance
      See Also:

    • getSocketChannelConfigurator

      public SocketChannelConfigurator getSocketChannelConfigurator()

    • setSocketChannelConfigurator

      public void setSocketChannelConfigurator(SocketChannelConfigurator configurator)
      Set the SocketChannel configurator. This gets a chance to "configure" a socket channel before it has been opened. The default implementation disables Nagle's algorithm.
      Parameters:
      configurator - the configurator to use

    • getSslEngineConfigurator

      public SslEngineConfigurator getSslEngineConfigurator()

    • setSslEngineConfigurator

      public void setSslEngineConfigurator(SslEngineConfigurator configurator)
      Set the SSLEngine configurator. This gets a change to "configure" the SSL engine before the connection has been opened. This can be used e.g. to set SSLParameters. The default implementation doesn't do anything.
      Parameters:
      configurator - the configurator to use

    • getConnectionShutdownExecutor

      public ExecutorService getConnectionShutdownExecutor()

    • setConnectionShutdownExecutor

      public NioParams setConnectionShutdownExecutor(ExecutorService connectionShutdownExecutor)
      Set the ExecutorService used for connection shutdown. If not set, falls back to the NIO executor and then the thread factory. This executor service is useful when strict control of the number of threads is necessary, the application can experience the closing of several connections at once, and automatic recovery is enabled. In such cases, the connection recovery can take place in the same pool of threads as the NIO operations, which can create deadlocks (all the threads of the pool are busy recovering, and there's no thread left for NIO, so connections never recover).

      Note it's developer's responsibility to shut down the executor when it is no longer needed.

      Using the thread factory for such scenarios avoid the deadlocks, at the price of potentially creating many short-lived threads in case of massive connection lost.

      With both the NIO and connection shutdown executor services set and configured accordingly, the application can control reliably the number of threads used.

      Parameters:
      connectionShutdownExecutor - the executor service to use
      Returns:
      this NioParams instance
      Since:
      5.4.0
      See Also:

    • setByteBufferFactory

      public NioParams setByteBufferFactory(ByteBufferFactory byteBufferFactory)
      Set the factory to create ByteBuffers.

      The default implementation creates heap-based ByteBuffers.

      Parameters:
      byteBufferFactory - the factory to use
      Returns:
      this NioParams instance
      Since:
      5.5.0
      See Also:

    • getByteBufferFactory

      public ByteBufferFactory getByteBufferFactory()

    • setWriteQueueFactory

      public NioParams setWriteQueueFactory(Function<NioContext,NioQueue> writeQueueFactory)
      Set the factory to create NioQueues.

      The default uses a ArrayBlockingQueue.

      Parameters:
      writeQueueFactory - the factory to use
      Returns:
      this NioParams instance
      Since:
      5.5.0
      See Also:

    • getWriteQueueFactory

      public Function<NioContext,NioQueue> getWriteQueueFactory()