Class NioParams


  • public class NioParams
    extends Object
    Parameters used to configure the NIO mode of a ConnectionFactory.
    Since:
    4.0.0
    • Constructor Detail

      • NioParams

        public NioParams()
      • NioParams

        public NioParams​(NioParams nioParams)
    • Method Detail

      • 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:
        setWriteQueueCapacity(int)
      • 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:
        setWriteEnqueuingTimeoutInMs(int)
      • 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
      • 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:
        setNioExecutor(ExecutorService)