org.apache.tomcat.util.net

## Class NioSelectorPool

- java.lang.Object
- - org.apache.tomcat.util.net.NioSelectorPool

    public class NioSelectorPool
    extends Object

Thread safe non blocking selector pool

Since:
  6.0
Version:
  1.0
Author:
  Filip Hanik

### Field Summary

Fields
`protected AtomicInteger` `active`
`protected NioBlockingSelector` `blockingSelector`
`protected boolean` `enabled`
`protected int` `maxSelectors`
`protected int` `maxSpareSelectors`
`protected ConcurrentLinkedQueue<Selector>` `selectors`
`protected static boolean` `SHARED`
`protected Selector` `SHARED_SELECTOR`
`protected long` `sharedSelectorTimeout`
`protected AtomicInteger` `spare`

### Constructor Summary

Constructors
Constructor and Description
`NioSelectorPool()`

### Method Summary

Methods
`void` `close()`
`Selector` `get()`
`int` `getMaxSelectors()`
`int` `getMaxSpareSelectors()`
`ConcurrentLinkedQueue<Selector>` `getSelectors()`
`protected Selector` `getSharedSelector()`
`long` `getSharedSelectorTimeout()`
`AtomicInteger` `getSpare()`
`boolean` `isEnabled()`
`void` `open()`
`void` `put(Selector s)`
`int` `read(ByteBuffer buf, NioChannel socket, Selector selector, long readTimeout)` Performs a blocking read using the bytebuffer for data to be read and a selector to block.
`int` `read(ByteBuffer buf, NioChannel socket, Selector selector, long readTimeout, boolean block)` Performs a read using the bytebuffer for data to be read and a selector to register for events should you have the block=true.
`void` `setEnabled(boolean enabled)`
`void` `setMaxSelectors(int maxSelectors)`
`void` `setMaxSpareSelectors(int maxSpareSelectors)`
`void` `setSharedSelectorTimeout(long sharedSelectorTimeout)`
`int` `write(ByteBuffer buf, NioChannel socket, Selector selector, long writeTimeout)` Performs a blocking write using the bytebuffer for data to be written and a selector to block.
`int` `write(ByteBuffer buf, NioChannel socket, Selector selector, long writeTimeout, boolean block)`

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

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

### Field Detail

#### SHARED

    protected static final boolean SHARED

#### blockingSelector

    protected NioBlockingSelector blockingSelector

#### SHARED_SELECTOR

    protected volatile Selector SHARED_SELECTOR

#### maxSelectors

    protected int maxSelectors

#### sharedSelectorTimeout

    protected long sharedSelectorTimeout

#### maxSpareSelectors

    protected int maxSpareSelectors

#### enabled

    protected boolean enabled

#### active

    protected AtomicInteger active

#### spare

    protected AtomicInteger spare

#### selectors

    protected ConcurrentLinkedQueue<Selector> selectors

### Constructor Detail

#### NioSelectorPool

    public NioSelectorPool()

### Method Detail

#### getSharedSelector

    protected Selector getSharedSelector()
                                  throws IOException

Throws:
  `IOException`

#### get

    public Selector get()
                 throws IOException

Throws:
  `IOException`

#### put

    public void put(Selector s)
             throws IOException

Throws:
  `IOException`

#### close

    public void close()
               throws IOException

Throws:
  `IOException`

#### open

    public void open()
              throws IOException

Throws:
  `IOException`

#### write

    public int write(ByteBuffer buf,
            NioChannel socket,
            Selector selector,
            long writeTimeout)
              throws IOException

Performs a blocking write using the bytebuffer for data to be written and a selector to block. If the `selector` parameter is null, then it will perform a busy write that could take up a lot of CPU cycles.

Parameters:
  `buf` - ByteBuffer - the buffer containing the data, we will write as long as `(buf.hasRemaining()==true)`
  `socket` - SocketChannel - the socket to write data to
  `selector` - Selector - the selector to use for blocking, if null then a busy write will be initiated
  `writeTimeout` - long - the timeout for this write operation in milliseconds, -1 means no timeout
Returns:
  int - returns the number of bytes written
Throws:
  `EOFException` - if write returns -1
  `SocketTimeoutException` - if the write times out
  `IOException` - if an IO Exception occurs in the underlying socket logic

#### write

    public int write(ByteBuffer buf,
            NioChannel socket,
            Selector selector,
            long writeTimeout,
            boolean block)
              throws IOException

Throws:
  `IOException`

#### read

    public int read(ByteBuffer buf,
           NioChannel socket,
           Selector selector,
           long readTimeout)
             throws IOException

Performs a blocking read using the bytebuffer for data to be read and a selector to block. If the `selector` parameter is null, then it will perform a busy read that could take up a lot of CPU cycles.

Parameters:
  `buf` - ByteBuffer - the buffer containing the data, we will read as until we have read at least one byte or we timed out
  `socket` - SocketChannel - the socket to write data to
  `selector` - Selector - the selector to use for blocking, if null then a busy read will be initiated
  `readTimeout` - long - the timeout for this read operation in milliseconds, -1 means no timeout
Returns:
  int - returns the number of bytes read
Throws:
  `EOFException` - if read returns -1
  `SocketTimeoutException` - if the read times out
  `IOException` - if an IO Exception occurs in the underlying socket logic

#### read

    public int read(ByteBuffer buf,
           NioChannel socket,
           Selector selector,
           long readTimeout,
           boolean block)
             throws IOException

Performs a read using the bytebuffer for data to be read and a selector to register for events should you have the block=true. If the `selector` parameter is null, then it will perform a busy read that could take up a lot of CPU cycles.

Parameters:
  `buf` - ByteBuffer - the buffer containing the data, we will read as until we have read at least one byte or we timed out
  `socket` - SocketChannel - the socket to write data to
  `selector` - Selector - the selector to use for blocking, if null then a busy read will be initiated
  `readTimeout` - long - the timeout for this read operation in milliseconds, -1 means no timeout
  `block` - - true if you want to block until data becomes available or timeout time has been reached
Returns:
  int - returns the number of bytes read
Throws:
  `EOFException` - if read returns -1
  `SocketTimeoutException` - if the read times out
  `IOException` - if an IO Exception occurs in the underlying socket logic

#### setMaxSelectors

    public void setMaxSelectors(int maxSelectors)

#### setMaxSpareSelectors

    public void setMaxSpareSelectors(int maxSpareSelectors)

#### setEnabled

    public void setEnabled(boolean enabled)

#### setSharedSelectorTimeout

    public void setSharedSelectorTimeout(long sharedSelectorTimeout)

#### getMaxSelectors

    public int getMaxSelectors()

#### getMaxSpareSelectors

    public int getMaxSpareSelectors()

#### isEnabled

    public boolean isEnabled()

#### getSharedSelectorTimeout

    public long getSharedSelectorTimeout()

#### getSelectors

    public ConcurrentLinkedQueue<Selector> getSelectors()

#### getSpare

    public AtomicInteger getSpare()