Java NIO and TCP Connections

Internal

• TCP
• Java Non-Blocking I/O Concepts

Overview

This article describes the programming model involved in establishing a simple TCP connection and interacting with it with non-blocking I/O, from Java. We use Java NIO APIs primitives introduced in Java 4.

Programming Model

Server

The server code uses a Selector to multiplex over selectable channels: selectable channels: a ServerSocketChannel that listens for incoming network connections and creates new SocketChannels for each new TCP connection, and subsequently registered SocketChannels.

//
// Main selector multiplexor. We use the main thread as selector thread.
//

Selector selector = Selector.open();

//
// The ServerSocketChannel used to accept new TCP connections
//

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
InetSocketAddress address = new InetSocketAddress(PORT);
ServerSocket ss = serverSocketChannel.socket();
ss.bind(address);

//
// Register the ServerSocketChannel with the selector
//

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

The main event loop handles two types of events: new connections and data availability on the existing connections. Once a new connection is detected, the selector thread retrieves the corresponding SocketChannel and registers it with the same selector. If data becomes available on any of the registered SocketChannels, we use a Buffer to read it.

//
// The main event loop
//

while(true) {

  //
  // This call blocks until at least one I/O event occurs
  //

  selector.select();

  Set<SelectionKey> selectedKeys = selector.selectedKeys();

  for(Iterator<SelectionKey> i = selectedKeys.iterator(); i.hasNext(); ) {

        //
        // Figure out what kind of I/O event was selected
        //

        SelectionKey k = i.next();

        if ((k.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {

           //
           // New connection
           //

           c.info(TIMESTAMP_FORMAT.format(new Date()) + ": new connection");

           //
           // Remove the key from the set
           //

           i.remove();

            //
            // Retrieve the SocketChannel for the new connection, make it non-blocking, and register
            // it with the same selector so now we can handle incoming data events on the same event
            // loop
            //

            ServerSocketChannel ssc = (ServerSocketChannel)k.channel();
            SocketChannel sc = ssc.accept();
            sc.configureBlocking(false);
            sc.register(selector, SelectionKey.OP_READ);

             //
             // TODO this is where we pass the channel to a console subsystem to send data back on it
             //

        }
       else if ((k.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {

             //
             // New data available, read it
             //

             //
             // Remove the key from the set
             //

             i.remove();

             SocketChannel sc = (SocketChannel)k.channel();
             ByteBuffer buffer = ByteBuffer.allocate(1024);
             int bytesRead = sc.read(buffer);

             if (bytesRead == -1) {

                 //
                 // TCP connection was closed
                 //

                 c.info(TIMESTAMP_FORMAT.format(new Date()) + ": TCP connection closed");

                 //
                 // Unregister the channel, by canceling the key. If we don't do this, data availability
                 // events for zero-length data will keep popping up.
                 //

                 k.cancel();

            }
            else {

                  //
                  // Read data
                  //

                  buffer.flip();
                  byte[] content = new byte[bytesRead];
                  buffer.get(content, 0, bytesRead);

                  c.info(TIMESTAMP_FORMAT.format(new Date()) + ": " + new String(content));
          }
      }
   }
}

Client

Example

Playground Java NIO and TCP Connections