More tips for using NIO and NIO.2

“NIO shines when it’s used to boost processing performance, but its results are closely tied to the underlying platform. For instance, you might discover that NIO’s ability to accelerate application performance depends not only on the OS, but on the specific JVM, host virtualization context, mass storage characteristics, and even data…”— From “Five ways to maximize Java NIO and NIO.2”

TheAsynchronousServerSocketChannel provides a non-blocking asynchronous channel for stream-oriented listening sockets. In order to use it, we first execute its staticopen() method and thenbind() it to a specific port. Next, we’ll execute itsaccept() method, passing to it a class that implements theCompletionHandler interface. Most often, you’ll find thathandler created as an anonymous inner class.

Listing 3 shows the source code for our new asynchronous Echo Server.

Listing 3. SimpleSocketServer.java

package com.geekcap.javaworld.nio2;import java.io.I/OException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.AsynchronousServerSocketChannel;import java.nio.channels.AsynchronousSocketChannel;import java.nio.channels.CompletionHandler;import java.util.concurrent.ExecutionException;import java.util.concurrent.TimeUnit;import java.util.concurrent.TimeoutException;public class NioSocketServer{    public NioSocketServer()    {        try        {            // Create an AsynchronousServerSocketChannel that will listen on port 5000            final AsynchronousServerSocketChannel listener =                    AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(5000));            // Listen for a new request            listener.accept( null, new CompletionHandler<AsynchronousSocketChannel,Void>() {                @Override                public void completed(AsynchronousSocketChannel ch, Void att)                {                    // Accept the next connection                    listener.accept( null, this );                    // Greet the client                    ch.write( ByteBuffer.wrap( "Hello, I am Echo Server 2020, let's have an engaging conversation!n".getBytes() ) );                    // Allocate a byte buffer (4K) to read from the client                    ByteBuffer byteBuffer = ByteBuffer.allocate( 4096 );                    try                    {                        // Read the first line                        int bytesRead = ch.read( byteBuffer ).get( 20, TimeUnit.SECONDS );                        boolean running = true;                        while( bytesRead != -1 && running )                        {                            System.out.println( "bytes read: " + bytesRead );                            // Make sure that we have data to read                            if( byteBuffer.position() > 2 )                            {                                // Make the buffer ready to read                                byteBuffer.flip();                                // Convert the buffer into a line                                byte[] lineBytes = new byte[ bytesRead ];                                byteBuffer.get( lineBytes, 0, bytesRead );                                String line = new String( lineBytes );                                // Debug                                System.out.println( "Message: " + line );                                // Echo back to the caller                                ch.write( ByteBuffer.wrap( line.getBytes() ) );                                // Make the buffer ready to write                                byteBuffer.clear();                                // Read the next line                                bytesRead = ch.read( byteBuffer ).get( 20, TimeUnit.SECONDS );                            }                            else                            {                                // An empty line signifies the end of the conversation in our protocol                                running = false;                            }                        }                    }                    catch (InterruptedException e)                    {                        e.printStackTrace();                    }                    catch (ExecutionException e)                    {                        e.printStackTrace();                    }                    catch (TimeoutException e)                    {                        // The user exceeded the 20 second timeout, so close the connection                        ch.write( ByteBuffer.wrap( "Good Byen".getBytes() ) );                        System.out.println( "Connection timed out, closing connection" );                    }                    System.out.println( "End of conversation" );                    try                    {                        // Close the connection if we need to                        if( ch.isOpen() )                        {                            ch.close();                        }                    }                    catch (I/OException e1)                    {                        e1.printStackTrace();                    }                }                @Override                public void failed(Throwable exc, Void att) {                    ///...                }            });        }        catch (I/OException e)        {            e.printStackTrace();        }    }    public static void main( String[] args )    {        NioSocketServer server = new NioSocketServer();        try        {            Thread.sleep( 60000 );        }        catch( Exception e )        {            e.printStackTrace();        }    }}

In Listing 3 we first create a newAsynchronousServerSocketChannel and then bind it to port 5000:

        final AsynchronousServerSocketChannel listener =              AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(5000));

From thisAsynchronousServerSocketChannel, we invokeaccept() to tell it to start listening for connections, passing to it a customCompletionHandler instance. When we invokeaccept(), it returns immediately. Note that this example is different from theServerSocket class in Listing 1; whereas theaccept() method blocked until a client connected to it, theAsynchronousServerSocketChannelaccept() method handles it for us.

The completion handler

Our next responsibility is to create aCompletionHandler class and provide an implementation of thecompleted() andfailed() methods. Thecompleted() method is called when theAsynchronousServerSocketChannel receives a connection from a client and it includes anAsynchronousSocketChannel to the client. Thecompleted() method first accepts the connection from theAsynchronousServerSocketChannel and then starts communicating with the client. The first thing that it does is write out a “Hello” message: It builds a string, converts it to a byte array, and then passes it toByteBuffer.wrap() to construct aByteBuffer. TheByteBuffer can then be passedAsynchronousSocketChannel‘swrite() method.

To read from the client, we create a newByteBuffer by invoking itsallocate(4096) (which creates a 4K buffer), then we invoke theAsynchronousSocketChannel‘sread() method. Theread() returns aFuture<Integer> on which we can invokeget() to retrieve the number of bytes read from the client. In this example, we passget() a timeout value of 20 seconds: if we do not get a response in 20 seconds then theget() method will throw aTimeoutException. Our rule for this echo server is that if we observe 20 seconds of silence then we terminate the conversation.

Futures in asynchronous computation

“TheFuture<V> interface represents the result of an asynchronous computation. The result is known as afuture because it typically will not be available until some moment in the future. You can invoke methods to cancel a task, return a task’s result (waiting indefinitely or for a timeout to elapse when the task hasn’t finished), and determine if a task has been cancelled or has finished…”–From “Java concurrency without the pain, Part 1”

Next we check the position of the buffer, which will be the location of the last byte received from the client. If the client sends an empty line then we receive two bytes: a carriage return and a line feed. The check ensures that if the client sends a blank line that we take it as an indicator that the client is finished with the conversation. If we have meaningful data then we call theByteBuffer‘sflip() method to prepare it for reading. We create a temporary byte array to hold the number of bytes read from the client and then invoke theByteBuffer‘sget() to load data into that byte array. Finally, we convert the byte array to a string by creating a newString instance. We echo the line back to the client by converting the string to a byte array, passing that to theByteBuffer.wrap() method and invoking theAsynchronousSocketChannel‘swrite() method. Now weclear() theByteBuffer, which recall means that it repositions theposition to zero and puts theByteBuffer into write mode, and then we read the next line from the client.

The only thing to be aware of is that themain() method, which creates the server, also sets up a 60 second timer to keep the application running. Because theAsynchronousSocketChannel‘saccept() method returns immediately, if we don’t have theThread.sleep() then our application will stop immediately.

To test this out, launch the server and connect to it using a telnet client:

telnet localhost 5000

Send a few strings to the server, observe that they are echoed back to you, and then send an empty line to terminate the conversation.

In conclusion

In this article I’ve presented two approaches to socket programming with Java: the traditional approach introduced with Java 1.0 and the newer, non-blocking NIO and NIO.2 approaches introduced in Java 1.4 and Java 7, respectively. You’ve seen several iterations of a Java socket client and a Java socket server example, demonstrating both the utility of basic Java I/O and some scenarios where non-blocking I/O improves the Java socket programming model. Using non-blocking I/O, you can program Java networked applications to handle multiple simultaneous connections without having to manage multiple thread collections. You can also take advantage of the new server scalability that is built in to NIO and NIO.2.