Non-Blocking I/O Implementation Issue

Question

Hi All,
I am trying out the latest JDK 1.4 java.nio.* package. I modified the NBTimeServer and wrote a client which connects to the NBTimeServer and tries to pass messages to and fro. I always succeed to pass on roundtrip of msgs and then Server blocks my client forever. I have modified NBTimeServer to accomodate one client only. Any help or comments on this would be really appreciated. Code is below. Feel free to try it out if want to see what I am trying to convey in this message.
/*******Server Code*******/
Modified this code to test mulitple to and fro msgs between client and server.
Only one client will ever be able to connect to this server during life of a server.
My point here is to demonstrate the to and fro comm between one client and one server
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.*;
import java.util.*;
import java.nio.charset.*;
import java.util.regex.*;
// Listen on a port for connections and write back the current time.
public class NBTimeServer {
private static final int DEFAULT_TIME_PORT = 8900;
// Constructor with no arguments creates a time server on default port.
public NBTimeServer() throws Exception {
     acceptConnections(this.DEFAULT_TIME_PORT);
// Constructor with port argument creates a time server on specified port.
public NBTimeServer(int port) throws Exception {
     acceptConnections(port);
// Accept connections for current time. Lazy Exception thrown.
private static void acceptConnections(int port) throws Exception {
     // Selector for incoming time requests
     Selector acceptSelector = SelectorProvider.provider().openSelector();
     Selector rwSelector = SelectorProvider.provider().openSelector();
     // Create a new server socket and set to non blocking mode
     ServerSocketChannel ssc = ServerSocketChannel.open();
     ssc.configureBlocking(false);
     // Bind the server socket to the local host and port
     InetAddress lh = InetAddress.getLocalHost();
     InetSocketAddress isa = new InetSocketAddress(lh, port);
     ssc.socket().bind(isa);
     // Register accepts on the server socket with the selector. This
     // step tells the selector that the socket wants to be put on the
     // ready list when accept operations occur, so allowing multiplexed
     // non-blocking I/O to take place.
     SelectionKey acceptKey = ssc.register(acceptSelector,
                         SelectionKey.OP_ACCEPT);
     int keysAdded = 0;
     // Here's where everything happens. The select method will
     // return when any operations registered above have occurred, the
     // thread has been interrupted, etc.
     while ((keysAdded = acceptSelector.select()) > 0) {
     // Someone is ready for I/O, get the ready keys
     Set readyKeys = acceptSelector.selectedKeys();
     Iterator i = readyKeys.iterator();
     // Walk through the ready keys collection and process date requests.
     while (i.hasNext()) {
          SelectionKey sk = (SelectionKey)i.next();
          i.remove();
          // The key indexes into the selector so you
          // can retrieve the socket that's ready for I/O
          ServerSocketChannel nextReady =
          (ServerSocketChannel)sk.channel();
          // Accept the date request and send back the date string
          Socket s = nextReady.accept();
                    SocketChannel sc = s.getChannel();
System.out.println("Got client channel..");
          sc.configureBlocking(false);
          SelectionKey readKey = sc.register(rwSelector,
                         SelectionKey.OP_READ|SelectionKey.OP_WRITE);                     
          int count = 0;
while(true) {
if((count = rwSelector.select(1000L)) > 0) {
Set readKeys = rwSelector.selectedKeys();
Iterator i1 = readKeys.iterator();
while(i1.hasNext()) {
System.out.println("Loop in Iterator");
SelectionKey sk1 = (SelectionKey)i1.next();
i1.remove();
if(sk1.isReadable()) {
DataInputStream sin = new DataInputStream(new BufferedInputStream(s.getInputStream(), 4096));
System.out.println(sin.readInt());
if(sk1.isWritable()) {
DataOutputStream sout = new DataOutputStream(new BufferedOutputStream(s.getOutputStream(), 4096));
PrintWriter out = new PrintWriter(sout, true);
          Date now = new Date();
          out.println(now);
// Entry point.
public static void main(String[] args) {
     // Parse command line arguments and
     // create a new time server (no arguments yet)
     try {
          NBTimeServer nbt = new NBTimeServer();
     } catch(Exception e) {
          e.printStackTrace();          
/******End Server Code********/
/*****Begin Client Code********/
import java.io.*;
import java.net.*;
import java.util.*;
// Listen on a port for connections and write back the current time.
public class NBTimeClient {
private static final int DEFAULT_TIME_PORT = 8900;
public static void main(String args[]) throws Exception {
InetAddress lh = InetAddress.getLocalHost();
Socket s = new Socket(lh, DEFAULT_TIME_PORT);
DataInputStream din = new DataInputStream(new BufferedInputStream(s.getInputStream(), 4096));
DataOutputStream dout = new DataOutputStream(new BufferedOutputStream(s.getOutputStream(), 4096));
//Read the time
System.out.println(din.readLine());
//send some junk which is read by server
dout.writeInt(1299);
dout.flush();
//read time again -- I never get anything here and I am blocked here...
System.out.println(din.readLine());
//send some junk back to the server
dout.writeInt(1299);
dout.flush();
s.close();
/*******End Client Code**********/
thanks,
Xtrimity

Answer 1

The reason it blocks forever is that you need to keep reusing your main select. That is where the non-blocking event will come from. Here is a bit of code that doesn't block forever.
Tim
http://tim.owlmountain.com
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.*;
import java.util.*;
import org.apache.log4j.*;
public class NBServer3 {
int _port = 4000;
Selector _selector = null;
ServerSocketChannel _selectableChannel = null;
int _keysAdded = 0;
static Category log =
Category.getInstance(NBServer3.class.getName());
static String QUIT_SERVER = "quit";
public NBServer3() {
public NBServer3( int port ) {
this._port = port;
public void initialize()
throws IOException {
this._selector = SelectorProvider.provider().openSelector();
this._selectableChannel = ServerSocketChannel.open();
     this._selectableChannel.configureBlocking(false);
     InetAddress lh = InetAddress.getLocalHost();
     InetSocketAddress isa = new InetSocketAddress(lh, this._port );
     this._selectableChannel.socket().bind(isa);
public void finalize()
throws IOException {
this._selectableChannel.close();
this._selector.close();
public void acceptConnections()
throws IOException {
Selects a set of keys whose corresponding channels are ready for I/O
operations. This method performs a non-blocking selection operation.
If no channels have become selectable since the previous selection
operation then this method immediately returns zero.
Returns:
The number of keys, possibly zero, whose ready-operation sets
were updated by the selection operation
do {
SelectionKey acceptKey =
this._selectableChannel.register( this._selector,
SelectionKey.OP_ACCEPT );
log.debug( "Acceptor loop..." );
while (( this._keysAdded = acceptKey.selector().select()) > 0 ) {
log.debug( "Selector returned "
+ this._keysAdded + " ready for IO operations" );
Set readyKeys = this._selector.selectedKeys();
Iterator i = readyKeys.iterator();
while (i.hasNext()) {
SelectionKey key = (SelectionKey)i.next();
i.remove();
if ( key.isAcceptable() ) {
ServerSocketChannel nextReady =
(ServerSocketChannel)key.channel();
log.debug( "Processing selection key read="
+ key.isReadable() + " write=" + key.isWritable() +
" accept=" + key.isAcceptable() );
Socket s = nextReady.accept();
s.getChannel().configureBlocking( false );
SelectionKey readKey =
s.getChannel().register( this._selector,
SelectionKey.OP_READ );
readKey.attach( s );
else if ( key.isReadable() ) {
SelectableChannel nextReady =
(SelectableChannel) key.channel();
log.debug( "Processing selection key read="
+ key.isReadable() + " write=" + key.isWritable() +
" accept=" + key.isAcceptable() );
Socket socket = (Socket) key.attachment();
BufferedReader in = new BufferedReader(
new InputStreamReader( socket.getInputStream() ));
String line = null;
if ( (line = in.readLine() ) != null )
log.debug( line );
log.debug( "End acceptor loop..." );
} while ( false ); //FIXIT tim this should be false. justa test
public static void main( String[] args ) {
BasicConfigurator.configure();
NBServer3 nbServer = new NBServer3();
try {
nbServer.initialize();
} catch ( IOException e ) {
e.printStackTrace();
System.exit( -1 );
try {
nbServer.acceptConnections();
catch ( IOException e ) {
e.printStackTrace();
log.error( e );