Apache Tomcat 7.0.42

## 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
`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
`NioSelectorPool()`

Method Summary
`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()

Apache Tomcat 7.0.42

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.