NioSelectorPool (Apache Tomcat 8.0.15 API Documentation)

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

Field Summary

Fields
Modifier and Type	Field and Description
`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()

Constructors
Constructor and Description
`NioSelectorPool()`

Method Summary

Methods
Modifier and Type	Method and Description
`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, boolean block)` Performs a write using the bytebuffer for data to be written and a selector to block (if blocking is requested).

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,
        boolean block)
          throws IOException
```
    Performs a write using the bytebuffer for data to be written and a selector to block (if blocking is requested). If the selector parameter is null, and blocking is requested then it will perform a busy write that could take up a lot of CPU cycles.
    
    Parameters:
    buf - The buffer containing the data, we will write as long as (buf.hasRemaining()==true)
    socket - The socket to write data to
    selector - The selector to use for blocking, if null then a busy write will be initiated
    writeTimeout - The timeout for this write operation in milliseconds, -1 means no timeout
    block - true to perform a blocking write otherwise a non-blocking write will be performed
    
    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
  - 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()
```

Class NioSelectorPool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SHARED

blockingSelector

SHARED_SELECTOR

maxSelectors

sharedSelectorTimeout

maxSpareSelectors

enabled

active

spare

selectors

Constructor Detail

NioSelectorPool

Method Detail

getSharedSelector

get

put

close

open

write

read

read

setMaxSelectors

setMaxSpareSelectors

setEnabled

setSharedSelectorTimeout

getMaxSelectors

getMaxSpareSelectors

isEnabled

getSharedSelectorTimeout

getSelectors

getSpare