import java.nio.channels.SelectionKey; import java.io.IOException;  public interface EchoProtocol {  void handleAccept(SelectionKey key) throws IOException;  void handleRead(SelectionKey key) throws IOException;  void handleWrite(SelectionKey key) throws IOException; } 

import java.nio.channels.*; import java.nio.ByteBuffer; import java.io.IOException;  public class TCPEchoSelectorProtocol implements EchoProtocol{   private int bufSize; // Size of I/O buffer    public EchoSelectorProtocol(int bufSize) {     this.bufSize = bufSize;   }    public void handleAccept(SelectionKey key) throws IOException {     SocketChannel clntChan = ((ServerSocketChannel) key.channel()).accept();     clntChan.configureBlocking(false); // Must be nonblocking to register     // Register the selector with new channel for read and attach byte buffer     clntChan.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufSize));        }    public void handleRead(SelectionKey key) throws IOException {     // Client socket channel has pending data     SocketChannel clntChan = (SocketChannel) key.channel();     ByteBuffer buf = (ByteBuffer) key.attachment();     long bytesRead = clntChan.read(buf);     if (bytesRead == -1) { // Did the other end close?       clntChan.close();     } else if (bytesRead > 0) {       // Indicate via key that reading/writing are both of interest now.       key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);     }   }    public void handleWrite(SelectionKey key) throws IOException {     /*      * Channel is available for writing, and key is valid (i.e., client channel      * not closed).      */     // Retrieve data read earlier     ByteBuffer buf = (ByteBuffer) key.attachment();     buf.flip(); // Prepare buffer for writing     SocketChannel clntChan = (SocketChannel) key.channel();     clntChan.write(buf);     if (!buf.hasRemaining()) { // Buffer completely written?        //Nothing left, so no longer interested in writes       key.interestOps(SelectionKey.OP_READ);     }     buf.compact(); // Make room for more data to be read in   }  } 

import java.net.InetSocketAddress; import java.net.SocketException; import java.nio.ByteBuffer; import java.nio.channels.SocketChannel;  public class TCPEchoClientNonblocking {    public static void main(String args[]) throws Exception {     String server = "127.0.0.1"; // Server name or IP address     // Convert input String to bytes using the default charset     byte[] argument = "0123456789abcdefghijklmnopqrstuvwxyz".getBytes();      int servPort = 5500;      // Create channel and set to nonblocking     SocketChannel clntChan = SocketChannel.open();     clntChan.configureBlocking(false);      // Initiate connection to server and repeatedly poll until complete     if (!clntChan.connect(new InetSocketAddress(server, servPort))) {       while (!clntChan.finishConnect()) {         System.out.print("."); // Do something else       }     }     ByteBuffer writeBuf = ByteBuffer.wrap(argument);     ByteBuffer readBuf = ByteBuffer.allocate(argument.length);     int totalBytesRcvd = 0; // Total bytes received so far     int bytesRcvd; // Bytes received in last read     while (totalBytesRcvd < argument.length) {       if (writeBuf.hasRemaining()) {         clntChan.write(writeBuf);       }       if ((bytesRcvd = clntChan.read(readBuf)) == -1) {         throw new SocketException("Connection closed prematurely");       }       totalBytesRcvd += bytesRcvd;       System.out.print("."); // Do something else     }      System.out.println("Received: " + // convert to String per default charset         new String(readBuf.array(), 0, totalBytesRcvd).length());     clntChan.close();   } } 

import java.io.IOException; import java.net.InetSocketAddress; import java.nio.channels.*; import java.util.Iterator;  public class TCPServerSelector {   private static final int BUFSIZE = 256; // Buffer size (bytes)   private static final int TIMEOUT = 3000; // Wait timeout (milliseconds)      public static void main(String[] args) throws IOException {     int[] ports = {5500};     // Create a selector to multiplex listening sockets and connections     Selector selector = Selector.open();      // Create listening socket channel for each port and register selector     for (int port : ports) {       ServerSocketChannel listnChannel = ServerSocketChannel.open();       listnChannel.socket().bind(new InetSocketAddress(port));       listnChannel.configureBlocking(false); // must be nonblocking to register       // Register selector with channel. The returned key is ignored       listnChannel.register(selector, SelectionKey.OP_ACCEPT);     }      // Create a handler that will implement the protocol     TCPProtocol protocol = new TCPEchoSelectorProtocol(BUFSIZE);      while (true) { // Run forever, processing available I/O operations       // Wait for some channel to be ready (or timeout)       if (selector.select(TIMEOUT) == 0) { // returns # of ready chans         System.out.print(".");         continue;       }        // Get iterator on set of keys with I/O to process       Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();       while (keyIter.hasNext()) {         SelectionKey key = keyIter.next(); // Key is bit mask         // Server socket channel has pending connection requests?         if (key.isAcceptable()) {           System.out.println("----accept-----");           protocol.handleAccept(key);         }         // Client socket channel has pending data?         if (key.isReadable()) {           System.out.println("----read-----");           protocol.handleRead(key);         }         // Client socket channel is available for writing and          // key is valid (i.e., channel not closed)?         if (key.isValid() && key.isWritable()) {           System.out.println("----write-----");           protocol.handleWrite(key);         }         keyIter.remove(); // remove from set of selected keys       }     }   }    }