SO timeout relevance in non-blocking NIO ServerSocketChannel

I converted a threaded blocking server from using the standard blocking IO with a thread for each connection to using non-blocking NIO channels. Works great but I'm trying to understand the SO timeout relevance in the context of non-blocking NIO channels. Is there any relevance and should I set an SO timeout on the ServerSocket associated with a ServerSocketChannel and if so how should I handle it?

No. Socket timeouts are for blocking mode. If you need timeouts in non-blocking mode you have to do them yourself, taking advantage of the Selector.select(long timeout) method and keeping track of activity times per channel yourself. You should use that select() method anyway, rather than just blocking indefinitely, as it gives you a chance to catch up on housekeeping, dead channels, etc. For example as a very naive approach if nothing happens in say a select timeout of 10 minutes you might want to close all accepted SocketChannels.

Similar Messages

Java.io.IOException: Connection timed out while using non-blocking NIO

Hi,
I am using non-blocking NIO on jdk 1.6 to transfer files between two processes. The problem is that the sender thread times out on the write call even though it's in non-blocking mode. It doesn't make sense. The receiver on the other end is running fine, and even tries to read from the socket after the sender drops the connection, and throws a Connection reset by peer exception. I should mention that the receiver is sometimes busy doing other stuff, and may be a second or two late in issuing the read call. But if I understand correctly, default TCP timeout is about 2 minutes, so there's no reason why it should timeout in a second or two. I'd appreciate it if anyone has any insight.
Thanks!

No I have definitely completed the connection since I it happens a while after the transfer has actually started and part of the file has already been transferred. Oh btw, I should mention that it doesn't always happen. It's intermittent. And it's not a network issue since iperf tests between the two nodes show nothing unusual.

Using non-blocking NIO, need Main Thread wait?

I'm trying to utilize the New IO libraries to create a simple url check application. The application just tests return codes to make sure the list of urls I have are still valid.
I'm using the NIO libraries because I had problems with the URLConnection object hanging when I ran into a url where the server never replied. It just sat there waiting for a reply.
Now I have a new problem, the connection to the web server is now in a new thread and I need to wait for the connection to finish before using it. I can't figure out how to make the main app wait for the connection. All of the documentation I find for the Wait() method refers to threads and I can't find how to refer to the main application thread.
Any suggestions?
Josh

Ok, this is were I have some gaps in my Java knowledge. How do I wait for OP_CONNECT to fire. Is it like setting up a ActionListener but for a non-visual object?
Also what do you mean when you refer to deregistering it?
You don't need to explain everything. I would be happy if I was just pointed at the appropriate pages and I'll do the leg work.
Josh
If you're using NIO the connection can be handled in
the same thread as the I/O. Just wait for OP_CONNECT
to fire, deregister it, and away you go.

Non-Blocking I/O Implementation Issue

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

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 );

Non-Blocking SocketChannel read give Connection timed out

Hi,
My program is using Non-Block NIO SocketChannel for both Server and Client sides. However, if the connection between server and client has been idle for a while, when the client try to communicate with server, it gets blocked for a while (15 minutes) and then receives the following exception:
java.io.IOException: Connection timed out
     at sun.nio.ch.FileDispatcher.read0(Native Method)
     at sun.nio.ch.SocketDispatcher.read(Unknown Source)
     at sun.nio.ch.IOUtil.readIntoNativeBuffer(Unknown Source)
     at sun.nio.ch.IOUtil.read(Unknown Source)
     at sun.nio.ch.SocketChannelImpl.read(Unknown Source)
How can this be since the read is in Non-Blocking mode? Also, is there anyway to determine the timeout without being blocked?

This would mean that you are trying to read from the socket without having properly completed the connection, which timed out. I would say you are connecting in non-blocking mode but not calling finishConnect() when you get OP_CONNECT.

Non-blocking SocketChannel and close - huh?

It looks like closing a socketchannel that is in non-blocking mode can result in a dead drop of the connection, with some bytes that have already been sent and accepted (as in, 'consumed' from the buffer) being completely dropped.
In fact, I'm generally confused: Actual C non-blocking code has a similar setup for 'close' as you can see in SocketChannel's OP_CONNECT behaviour - just because you want to connect the socket doesn't mean it magically happends without blocking. Wait for a ready flag, then try again.
It should work the same way with close (you try to close, but it may not be possible without blocking).
Is this a huge gaping bug that no one quite figured out just yet, or did I miss something? I loathe to turn on linger, as that's just a crapshoot (you never know if it actually gets through. You could run into funny surprises once the server gets a bit busy. I'd rather not) and tends to cause massive leaks on linux, at least according to some google searches.
There seems to be slightly better performance (in that I have always received all data sofar) if I close the socket instead of the channel (socketChannel.socket().close() instead of socketChannel.close()) - but this has been a random attempt at 'making it work', and I can't find any documentation that backs up that this will DEFINITELY not lose any information without letting me know somehow. That still sounds impossible with this approach.

Actual C non-blocking code has a similar setup for
'close' as you can see in SocketChannel's
OP_CONNECT behaviour ...No it doesn't. I don't know what you mean by this.
Closing a socket is asynchronous, but it shouldn't lose any data - if the data can be delivered it will be, followed by the FIN. You don't know when it is delivered, and you don't get to hear about any errors such as an RST coming from the other end, say if it decided to close before reading all the data, or if some intermediate router hung you up.
I'm wondering if you are really dealing with all the short write and zero length write possibilities, i.e. whether the data isn't really still in your output buffer. Don't wish to teach you to suck eggs but there are some subtleties here.
Setting a positive linger timeout doesn't really help because Java doesn't tell you if the timeout expired. (I only asked for this about four years ago). You get to wait while any pending data is delivered, but you still have to guess about whether it all went or the timeout expired, and the behaviour after the timeout expires is platform-dependent: some (Windows) issue an RST, others (Unix) keep trying.
Blocking or non-blocking mode shouldn't make any difference to this (except that Linux will block on a positive linger timeout even in non-blocking mode, which is wrong), and whether you close the channel or the socket is immaterial as one calls the other anyway.
The reason why OP_CONNECT is different in blocking/non-blocking modes is that in blocking mode it won't return until the SYN-ACK is received, while in non-blocking mode it just sends the SYN and relies on you calling connect() again (at the C level) to collect the SYN-ACK, or not - this is what finishConnect() tells you.
tends to cause massive leaks on linux, at least
according to some google searchesIt can't, unless you are referring to the Helix client thing, which appears to be just a badly designed C++ class library with, for some reason, its own linger implementation outside the kernel.

Troubles with timeout using java.nio.channels and non-blocking sockets

Hello.
I have a server application that employs java.nio.channels with non-blocking sockets.
The server waits for connections. The client should connect and be first in sending data.
Timeouts are significant! If client exceeds the allowed time to send data, the server should break the connection.
The huge trouble I've discovered that I cannot control the timeout when client connects but remains silent.
My code looks as follows:
<pre>
Selector oSel;
SocketChannel oSockChan;
Socket oSock;
SelectionKey oSelKey;
Iterator<SelectionKey> oItSelKeys;
int iCurrState, iMask, iCount;
iCurrState = INT_SERVER_WORKING;
iMask = SelectionKey.OP_ACCEPT | SelectionKey.OP_CONNECT | SelectionKey.OP_READ | SelectionKey.OP_WRITE;
while ( iCurrState == INT_SERVER_WORKING )
try
*// retrieving next action*
iCount = oSel.select();
if ( iCount > 0 )
oItSelKeys = oSel.selectedKeys().iterator();
while ( oItSelKeys.hasNext() )
oSelKey = oItSelKeys.next();
oItSelKeys.remove();
if ( oSelKey.isValid() )
switch ( oSelKey.readyOps() & iMask ) {
case SelectionKey.OP_ACCEPT :
oSockChan = oSSockChan.accept();
oSockChan.configureBlocking(false);
oSock = oSockChan.socket();
oSock.setKeepAlive(true);
oSockChan.register(oSel,SelectionKey.OP_READ,new MyPacket(oSock.getInetAddress(),oSock.getPort()));
break;
case SelectionKey.OP_READ :
oSelKey.interestOps(0);
((MyPacket) oSelKey.attachment()).inRequest(); *// preparing request*
this.getReader().add(oSelKey); *// sending key to reading thread*
break;
case SelectionKey.OP_WRITE :
oSelKey.interestOps(0);
((MyRequest) oSelKey.attachment()).inResponse(); *// preparing response*
this.getWriter().add(oSelKey); *// sending key to writing thread*
break;
case SelectionKey.OP_CONNECT :
default :
*// nothing to do*
catch ( IOException oExcept )
*// do some actions*
</pre>
Timeouts are easily controlled by reading and writing threads (see OP_READ and OP_WRITE ).
But when a client just connects without consequent data send, the state of this connection remains as OP_ACCEPT. The connection remains open for arbitrarily large time and I cannot control it!
Please help with idea how can I terminate such connections!

How can I process the keys that weren't selected at the bottom of the loop? Should I use the method keys() ?Yes. Form a new set from keys() and removeAll(selectedKeys()). Do that before you process selectedKeys().
And the second moment: as I understood a single key may contain several operations simultaneously? Thus I should use several if's (but not if/else 'cause it's the equivalent of switch ... case ).If there is anything unclear about 'your switch statement is invalid. You need an if/else chain' I fail to see what it is. Try reading it again. And if several ifs were really the equivalent of "switch ... case", there wouldn't be a problem in the first place. They're not, and there is.

NIO Non-Blocking Server not Reading from Key

I have created a NIO non blocking server (below) and it will not pick up any input from the client.... My log doesnt even show that it enters the readKey() method, so it must be something before. Any help would be appreciated.
Scott
package jamb.server;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
import java.util.Set;
import java.util.logging.Logger;
import java.util.prefs.Preferences;
import jamb.server.client.Client;
public class Server {
        private Selector selector;
        private ServerSocketChannel serverChannel;
        private static Logger logger = Logger.getLogger("jamb.server");
        private static Preferences prefs = Preferences.systemRoot().node("/jamb/server");
        public void init() {
                logger.entering("jamb.server.Server", "init");
                //Get a selector...
                try {
                        selector = SelectorProvider.provider().openSelector();
                        //Open the SocketChannel and make it non-blocking...
                        serverChannel = ServerSocketChannel.open();
                     serverChannel.configureBlocking(false);
                        //Bind the server to the port....
                        int port = prefs.getInt("Port", 4000);
                        logger.config("Server configured on port " + port + " (default: 4000)");
                     InetSocketAddress isa = new InetSocketAddress(
                                InetAddress.getLocalHost(), port);
                     serverChannel.socket().bind(isa);
                } catch (IOException ioe) {
                        logger.severe ("IOException during server initialization!");
                logger.exiting("jamb.server.Server", "init");
        public void run() {
                logger.entering("jamb.server.Server", "run");
                int bufferSize = prefs.getInt("BufferSize", 8);
                logger.config("Buffer size set to " + bufferSize + " (default: 8)");
                SelectionKey acceptKey = null;
                try {
                        acceptKey = serverChannel.register(
                                selector, SelectionKey.OP_ACCEPT);
                } catch (ClosedChannelException cce) {
                try {
                        while (acceptKey.selector().select() > 0) {
                                Set readyKeys = selector.selectedKeys();
                                Iterator i = readyKeys.iterator();
                                while (i.hasNext()) {
                                        //logger.finest("Processing keys...");
                                        //Get the key from the set and remove it
                                        SelectionKey currentKey = (SelectionKey) i.next();
                                        i.remove();
                                        if (currentKey.isAcceptable()) {
                                                logger.finest("Accepting key...");
                                                acceptKey(currentKey);
                                        } else if (currentKey.isReadable()) {
                                                logger.finest("Reading key...");
                                                readKey(currentKey, bufferSize);
                                        } else if (currentKey.isWritable()) {
                                                //logger.finest("Writing key...");
                                                writeKey(currentKey);
                } catch (IOException ioe) {
                        logger.warning("IOException during key handling!");
                logger.exiting("jamb.server.Server", "run");
        public void flushClient (Client client) {
                try {
                        ByteBuffer buf = ByteBuffer.wrap( client.getOutputBuffer().toString().getBytes());
                        client.getChannel().write(buf);
                } catch (IOException ioe) {
                        System.out.println ("Error writing to player");
                client.setOutputBuffer(new StringBuffer());
        private void acceptKey (SelectionKey acceptKey) {
                logger.entering("jamb.server.Server", "acceptKey");
                //Retrieve a SocketChannel for the new client, and register a new selector with
                //read/write interests, and then register
                try {
                        SocketChannel channel = ((ServerSocketChannel) acceptKey.channel()).accept();
                        channel.configureBlocking(false);
                        SelectionKey readKey = channel.register(
                                selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE );
                        readKey.attach(new Client(this, channel));
                } catch (IOException ioe) {
                        System.out.println ("Error accepting key");
                logger.exiting("jamb.server.Server", "acceptKey");
        private void readKey (SelectionKey readKey, int bufSize) {
                logger.entering("jamb.server.Server", "readKey");
                Client client = (Client) readKey.attachment();
                try {
                        ByteBuffer byteBuffer = ByteBuffer.allocate(bufSize);
                        int nbytes = client.getChannel().read( byteBuffer );
                        byteBuffer.flip();
                        Charset charset = Charset.forName( "us-ascii" );
                        CharsetDecoder decoder = charset.newDecoder();
                        CharBuffer charBuffer = decoder.decode(byteBuffer);
                        String text = charBuffer.toString();
                        client.getInputBuffer().append(text);
                        if ( text.indexOf( "\n" ) >= 0 )
                                client.input();
                } catch (IOException ioe) {
                        logger.warning("Unexpected quit...");
                        client.disconnect();
                logger.exiting("jamb.server.Server", "readKey");
        private void writeKey (SelectionKey writeKey) {
                //logger.entering("jamb.server.Server", "writeKey");
                Client client = (Client) writeKey.attachment();
                if (!client.isConnected()) {
                        client.connect();
                //logger.exiting("jamb.server.Server", "writeKey");

From my own expierence with the NIO (Under Windows XP/ jdk1.4.1_01); you can't seem to set READ and WRITE at the same time.
The program flow I usually end up with for a echo server is:
When the selector.isAcceptable(): accept a connection; register for READs
In the read event; write the incoming characters to a buffer; register for a WRITE and add the buffer as an attachment.
In the write event; write the data to the socket If all the data was written; register for a READ; otherwise register for another WRITE so that you can write the rest.
Not sure if that the "proper" way; but it works well for me.
- Chris

JDK 1.4 nio non-blocking connects don't finish

I am working with the Linux version of JDK1.4, doing some testing of the
non-blocking capability. The few tests that I have done have shown some
strange results:
- When opening a non-blocking connection to a server which has an
announcement banner, say such as POP which gives something like:
+OK pop3 server ready
then connection seems to be OK and proceed through to completion.
- When opening a non-blocking connection to a server which is silent, and
expects me to start the conversation, such as contacting an HTTP server,
then the Selector.select() never returns to allow me to finish the
connection.
Below is a test program which illustrates the problem for me.
It attempts to open a non-blocking connection to www.yahoo.com on port 80.
It then drops into a Selector.select() where I am waiting for the chance to
catch the SelectionKey.OP_CONNECT event and finish connecting, and then send
a simple HTTP GET request down the wire. That OP_CONNECT event
never seems to arrive though, and I remain stuck in the select().
'netstat -na' shows that I am in a connection established state.
Any insight appreciated,
-Steve M [email protected]
------------------>8 cut here 8<-----------------------
import java.io.*;
import java.net.*;
import java.util.*;
import java.nio.*;
import java.nio.channels.*;
public class NoWorkee
public static String GET_REQUEST = "GET / HTTP/1.0\r\n\r\n";
    static class Context
        String host;
        int    port;
        ByteBuffer request;
        public Context (String h, int p, ByteBuffer r)
        {host=h; port=p; request=r;}
Selector sel = null;
boolean keepGoing = true;
public NoWorkee()
    throws IOException
    sel = Selector.open();
public void add(String host, int port)
    throws IOException
    int ops = SelectionKey.OP_CONNECT;
    // create non-blocking socket, and initiate connect operation
    SocketChannel sc = SocketChannel.open();
    sc.configureBlocking(false);
    sc.connect(new InetSocketAddress(InetAddress.getByName(host), port));
    SelectionKey sk;
    try
        sk = sc.register(sel, ops);
        System.out.println ( "sc.register looks good connected=" +
            sc.isConnected() + ", isConnectionPending=" +
            sc.isConnectionPending());
        sk.attach(new Context(host, port, ByteBuffer.wrap(GET_REQUEST.getBytes())));
    catch (IOException x)
        x.printStackTrace();
        sc.close();
public void run()
    throws IOException
    keepGoing = true;
    System.out.println ( "Selecting " + sel.keys().size() + " SelectKeys");
    while (keepGoing)
        final long before = System.currentTimeMillis();
        final int numReady = sel.select();
        //final int numReady = sel.select(1000);
        final long after = System.currentTimeMillis();
        System.out.println ( "Blocked " + (after-before) + " ms, numReady=" + numReady);
        if (numReady > 0)
            Set readyKeys = sel.selectedKeys();
            System.out.println ( "Selected keys size " + readyKeys.size());
            for (Iterator it = readyKeys.iterator(); it.hasNext();)
                SelectionKey sk = (SelectionKey)it.next();
                SocketChannel sockChan = (SocketChannel)sk.channel();
                Context ctx = (Context)sk.attachment();
                System.out.println ( "Servicing host " + ctx.host + " port "
                             ctx.port);
System.out.println ( "1");
                if (sk.isConnectable())
                    if (sockChan.finishConnect())
                        System.out.println ( "Finished connecting success "
+ sockChan);
                        int ops = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
                        sk.interestOps (ops);
                    else
                        System.out.println ( "Could not finishConnect for "
                            sockChan);
                        sk.cancel();
                        sockChan.close();
System.out.println ( "2");
                if (sk.isAcceptable())
                    System.out.println ( "in sk.isAcceptable() block");
System.out.println ( "3");
                if (sk.isReadable())
                    System.out.println ( "in sk.isReadable() block");
                    byte rawBuff[] = new byte[32 * 1024];
                    ByteBuffer buff = ByteBuffer.wrap(rawBuff);
                    int numRead = -1;
                    while (0 < (numRead = sockChan.read(buff)))
                        System.out.println ( "numRead = " + numRead);
                        for (int i = 0; i < numRead; i++)
                            System.out.print((char)rawBuff);
System.out.println ( "numRead = " + numRead);
System.out.println ( "4");
if (sk.isWritable())
System.out.println ( "in sk.isReadable() block");
int numWritten = -1;
if (null != ctx.request)
numWritten = sockChan.write(ctx.request);
if (!ctx.request.hasRemaining())
sk.interestOps(sk.interestOps() &
~SelectionKey.OP_WRITE);
System.out.println ( "numWritten = " + numWritten);
//else
// service timeouts
public static void main (String arg[])
try
NoWorkee bla = new NoWorkee();
bla.add ("www.yahoo.com", 80);
bla.run();
catch (Exception e)
e.printStackTrace();
------------------>8 cut here 8<-----------------------

Just for the benefit of anyone who might be seeing the same problem, it looks like bug 4457776 accurately describes the problem that I was having above.
I am downloading j2sdk-1_4_0-beta2-linux-i386-rpm.bin to see if that fixed it.
Reference:
http://developer.java.sun.com/developer/bugParade/bugs/4457776.html

NIO SocketChannel non-blocking read

Hello.
I'm not sure a resembling message has already been posted in a forum. In such a case, thanks for redirecting to it.
Goals :
A selector is used by a main server thread to make accept and read operations non-blocking.
When a connection is accepted, the newly created socket channel is configured as non-blocking, and a key is added to the selector with the OP_READ flag.
When data are available on sockets, a new task (runnable) is created and submitted to a thread pool.
When a thread is ready to process the request, a pre-allocated bytebuffer is used to read arriving data.
The problem :
When the bytebuffer capacity is less than the received bytes count, the read method on the socket channel interrupts the selector on the same selection key. In response to this event, a new task is initiated, interferring with the previous one.
As expected according to my concurrency policy (ie. with a pool of threads), several requests are processed by parallel threads. To avoid unsafe accesses, i added a synchronized statement on the channel blocking lock, and it seems to works fine. But a better way should exist...
Questions :
Is this the expected behavior ?
Is there any other way to read received data with a small buffer ?
The full copy of the source code :
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.nio.charset.*;
import java.net.*;
import java.util.*;
import net.moon.threads.*;
public class Nio1 {
     static class Request {
          boolean isCompleted = false;
          int inputs = 0;
          Set workers = new HashSet();
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          byte p = 0;
          boolean isCompleted() {
               return isCompleted;
          void countInput() {
               inputs++;
          void append(final ByteBuffer byteBuffer) {
               if (isCompleted)
                    throw new IllegalStateException("Request is already completed");
               workers.add(Thread.currentThread());
               while (byteBuffer.hasRemaining()) {
                    byte b = byteBuffer.get();
                    baos.write(b);
                    if ((b == '\r') && (p == '\n'))
                         isCompleted = true;
                    p = b;
          int inputs() {
               return inputs;
          Thread[] workers() {
               return (Thread[]) workers.toArray(new Thread[0]);
          int size() {
               return baos.size();
          byte[] getData() {
               return baos.toByteArray();
          void reset() {
               isCompleted = false;
               inputs = 0;
               baos.reset();
               workers.clear();
     static private class RequestTask implements Runnable {
     private final static Charset charset = Charset.forName("US-ASCII");
          private final Server server;
          private final SelectionKey selectionKey;
          RequestTask(final Server server, final SelectionKey selectionKey) {
               this.server = server;
               this.selectionKey = selectionKey;
          public void run() {
               log("*** Processing input...");
               try {
                    SocketChannel channel = (SocketChannel) selectionKey.channel();
synchronized(channel.blockingLock()) {
                    Request request = (Request) selectionKey.attachment();
                    request.countInput();
                    State state = getState();
                    log("Reading first...");
                    int c = channel.read(state.byteBuffer);
                    log("... Read first : " + c);
                    if (c > 0) {
                         for(;;) {
                              state.byteBuffer.flip();
                         request.append(state.byteBuffer);
                              state.byteBuffer.clear();
                              if (c < state.byteBuffer.capacity()) break;
                              log("Reading next...");
                              c = channel.read(state.byteBuffer);
                              log("... Read next : " + c);
                              if (c <= 0) break;
                         if (request.isCompleted()) {
                              log("Request completed : " + request.inputs());
                              StringBuffer bodyBuffer = new StringBuffer();
                              bodyBuffer.append("-----------------------------\r\n");
                              bodyBuffer.append("Request processed in " + request.inputs() + " inputs\r\n");
                              bodyBuffer.append("Request size is " + request.size() + " bytes\r\n");
                              bodyBuffer.append("Participating workers :\r\n");
                              Thread[] workers = request.workers();
                              for (int i = 0; i < workers.length; i++)
                                   bodyBuffer.append(" * " + workers[i] + "\r\n");
                              bodyBuffer.append("-----------------------------\r\n");
                              StringBuffer headerBuffer = new StringBuffer();
                              headerBuffer.append("HTTP/1.1 200 OK\r\n");
                              headerBuffer.append("Server: NIO Server 1\r\n");
                              headerBuffer.append("Content-Type: text/plain\r\n");
                              headerBuffer.append("Content-Length: ").append(request.size() + bodyBuffer.length()).append("\r\n");
                              headerBuffer.append("\r\n");
                         CharsetEncoder encoder = charset.newEncoder();
                              channel.write(encoder.encode(CharBuffer.wrap(headerBuffer)));
                              channel.write(encoder.encode(CharBuffer.wrap(bodyBuffer)));
                              channel.write(ByteBuffer.wrap(request.getData()));
                              request.reset();
                    if (c < 0) {
                         selectionKey.attach(null);
                         selectionKey.cancel();
                         log("!!! Connection terminated for channel " + channel);
               catch(final Exception x) {
                    x.printStackTrace();
               log("*** Request processed...");
          private State getState() {
               State state = (State) server.taskManager.getCurrentWorkerState();
               if (state == null) {
                    state = new State();
                    server.taskManager.setCurrentWorkerState(state);
               else {
                    state.byteBuffer.clear();
               return state;
          private void log(final String text) {
               System.out.println(Thread.currentThread() + " : " + text);
          static class State {
               ByteBuffer byteBuffer = ByteBuffer.allocateDirect(32);
     static private class Server implements Runnable {
          private final int port;
          private Thread worker;
          private FIFOTaskManager taskManager;
          Server(final int port) {
               this.port = port;
               worker = null;
          synchronized void start() throws Exception {
               if (worker == null) {
                    log("Starting the server...");
                    taskManager = new FIFOTaskManager("Nio1Workers", 24);
                    worker = new Thread(this);
                    worker.start();
                    synchronized(worker) {
                         try {
                              worker.wait();
                         catch(InterruptedException x) {
                    log("Server started !");
          public void run() {
               try {
                    log("Server is starting...");
                    Selector selector = SelectorProvider.provider().openSelector();
                    log("Creating listener on port " + port);
                    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                    serverSocketChannel.configureBlocking(false);
                    InetSocketAddress inetSocketAddress = new InetSocketAddress(port);
                    serverSocketChannel.socket().bind(inetSocketAddress);
                    SelectionKey selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
                    synchronized(worker) {
                         worker.notify();
                    while (selector.select() >= 0) {
                         Set readyKeys = selector.selectedKeys();
                         log("Keys are ready : " + readyKeys.size());
                         for (Iterator i = readyKeys.iterator(); i.hasNext(); ) {
                              SelectionKey selectedKey = (SelectionKey) i.next();
                              if (selectedKey.isAcceptable()) {
                                   ServerSocketChannel ssc = (ServerSocketChannel) selectedKey.channel();
                                   SocketChannel sc = ssc.accept();
                                   sc.configureBlocking(false);
                                   SelectionKey sk = sc.register(selector, SelectionKey.OP_READ);
                                   sk.attach(new Request());
                                   log("Connection accepted for channel " + sc);
                              else if (selectedKey.isReadable()) {
                                   log("Key ready for input : " + selectedKey);
                                   taskManager.execute(new RequestTask(this, selectedKey));
                              i.remove();
                         readyKeys = null;
                    log("Server loop interrupted !");
               catch(Exception x) {
                    x.printStackTrace();
          private void log(final String text) {
               System.out.println("SERVER: " + text);
     public static void main(final String[] args) throws Exception {
          Server server = new Server(9001);
          server.start();

Thanks for the trick. I hope the code will be more readable than my sockets !
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.nio.charset.*;
import java.net.*;
import java.util.*;
import net.moon.threads.*;
public class Nio1 {
     static class Request {
          boolean isCompleted = false;
          int inputs = 0;
          Set workers = new HashSet();
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          byte p = 0;
          boolean isCompleted() {
               return isCompleted;
          void countInput() {
               inputs++;
          void append(final ByteBuffer byteBuffer) {
               if (isCompleted)
                    throw new IllegalStateException("Request is already completed");
               workers.add(Thread.currentThread());
               while (byteBuffer.hasRemaining()) {
                    byte b = byteBuffer.get();
                    baos.write(b);
                    if ((b == '\r') && (p == '\n'))
                         isCompleted = true;
                    p = b;
          int inputs() {
               return inputs;
          Thread[] workers() {
               return (Thread[]) workers.toArray(new Thread[0]);
          int size() {
               return baos.size();
          byte[] getData() {
               return baos.toByteArray();
          void reset() {
               isCompleted = false;
               inputs = 0;
               baos.reset();
               workers.clear();
     static private class RequestTask implements Runnable {
         private final static Charset charset = Charset.forName("US-ASCII");
          private final Server server;
          private final SelectionKey selectionKey;
          RequestTask(final Server server, final SelectionKey selectionKey) {
               this.server = server;
               this.selectionKey = selectionKey;
          public void run() {
               log("*** Processing input...");
               try {
                    SocketChannel channel = (SocketChannel) selectionKey.channel();
synchronized(channel.blockingLock()) {
                    Request request = (Request) selectionKey.attachment();
                    request.countInput();
                    State state = getState();
                    log("Reading first...");
                    int c = channel.read(state.byteBuffer);
                    log("... Read first : " + c);
                    if (c > 0) {
                         for(;;) {
                              state.byteBuffer.flip();
                             request.append(state.byteBuffer);
                              state.byteBuffer.clear();
                              if (c < state.byteBuffer.capacity()) break;
                              log("Reading next...");
                              c = channel.read(state.byteBuffer);
                              log("... Read next : " + c);
                              if (c <= 0) break;
                         if (request.isCompleted()) {
                              log("Request completed : " + request.inputs());
                              StringBuffer bodyBuffer = new StringBuffer();
                              bodyBuffer.append("-----------------------------\r\n");
                              bodyBuffer.append("Request processed in " + request.inputs() + " inputs\r\n");
                              bodyBuffer.append("Request size is " + request.size() + " bytes\r\n");
                              bodyBuffer.append("Participating workers :\r\n");
                              Thread[] workers = request.workers();
                              for (int i = 0; i < workers.length; i++)
                                   bodyBuffer.append(" * " + workers[i] + "\r\n");
                              bodyBuffer.append("-----------------------------\r\n");
                              StringBuffer headerBuffer = new StringBuffer();
                              headerBuffer.append("HTTP/1.1 200 OK\r\n");
                              headerBuffer.append("Server: NIO Server 1\r\n");
                              headerBuffer.append("Content-Type: text/plain\r\n");
                              headerBuffer.append("Content-Length: ").append(request.size() + bodyBuffer.length()).append("\r\n");
                              headerBuffer.append("\r\n");
                             CharsetEncoder encoder = charset.newEncoder();
                              channel.write(encoder.encode(CharBuffer.wrap(headerBuffer)));
                              channel.write(encoder.encode(CharBuffer.wrap(bodyBuffer)));
                              channel.write(ByteBuffer.wrap(request.getData()));
                              request.reset();
                    if (c < 0) {
                         selectionKey.attach(null);
                         selectionKey.cancel();
                         log("!!! Connection terminated for channel " + channel);
               catch(final Exception x) {
                    x.printStackTrace();
               log("*** Request processed...");
          private State getState() {
               State state = (State) server.taskManager.getCurrentWorkerState();
               if (state == null) {
                    state = new State();
                    server.taskManager.setCurrentWorkerState(state);
               else {
                    state.byteBuffer.clear();
               return state;
          private void log(final String text) {
               System.out.println(Thread.currentThread() + " : " + text);
          static class State {
               ByteBuffer byteBuffer = ByteBuffer.allocateDirect(32);
     static private class Server implements Runnable {
          private final int port;
          private Thread worker;
          private FIFOTaskManager taskManager;
          Server(final int port) {
               this.port = port;
               worker = null;
          synchronized void start() throws Exception {
               if (worker == null) {
                    log("Starting the server...");
                    taskManager = new FIFOTaskManager("Nio1Workers", 24);
                    worker = new Thread(this);
                    worker.start();
                    synchronized(worker) {
                         try {
                              worker.wait();
                         catch(InterruptedException x) {
                    log("Server started !");
          public void run() {
               try {
                    log("Server is starting...");
                    Selector selector = SelectorProvider.provider().openSelector();
                    log("Creating listener on port " + port);
                    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                    serverSocketChannel.configureBlocking(false);
                    InetSocketAddress inetSocketAddress = new InetSocketAddress(port);
                    serverSocketChannel.socket().bind(inetSocketAddress);
                    SelectionKey selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
                    synchronized(worker) {
                         worker.notify();
                    while (selector.select() >= 0) {
                         Set readyKeys = selector.selectedKeys();
                         log("Keys are ready : " + readyKeys.size());
                         for (Iterator i = readyKeys.iterator(); i.hasNext(); ) {
                              SelectionKey selectedKey = (SelectionKey) i.next();
                              if (selectedKey.isAcceptable()) {
                                   ServerSocketChannel ssc = (ServerSocketChannel) selectedKey.channel();
                                   SocketChannel sc = ssc.accept();
                                   sc.configureBlocking(false);
                                   SelectionKey sk = sc.register(selector, SelectionKey.OP_READ);
                                   sk.attach(new Request());
                                   log("Connection accepted for channel " + sc);
                              else if (selectedKey.isReadable()) {
                                   log("Key ready for input : " + selectedKey);
                                   taskManager.execute(new RequestTask(this, selectedKey));
                              i.remove();
                         readyKeys = null;
                    log("Server loop interrupted !");
               catch(Exception x) {
                    x.printStackTrace();
          private void log(final String text) {
               System.out.println("SERVER: " + text);
     public static void main(final String[] args) throws Exception {
          Server server = new Server(9001);
          server.start();
}

NIO: Strange problem when using ByteBuffer with non-blocking SocketChannel

Hi,
I have a server that uses multiplexed, non-blocking I/O with java.nio. When a client connects, the server waits for the message: <system cmd="knock"/>, returns a message and disconnects the client. The clients are shortly serviced in less than a second.
But the server newer receive anything from about 20% of the clients - even though it is sent. Or with other words: it is received and the data is contained in the ByteBuffer - SocketChannel.read(ByteBuffer) - but a call to ByteBuffer.remaing() returns 0 !!
ByteBuffer receiveBuf = ByteBuffer.allocate(65536);
receiveBuf.clear(); // the code is elsewhere used for longer living clients
int readBytes = channel.read(receiveBuf);
receiveBuf.flip();
StringBuffer sb = new StringBuffer();
System.out.println(" * Remaining: "+receiveBuf.remaining()); // writes: ' * Remaining: 0'
System.out.println(" * Received: "+new String(receiveBuf.array())); // writes: ' * Received: <system cmd="knock"/>'
while(receiveBuf.remaining() >= 2) {
byte b = receiveBuf.get();
sb.append((char)b);
System.out.println(" * sb content: "+sb.toString()); // writes: ' * sb content: 'The ByteBuffer clearly receives the correct data, but the ByteBuffer.remaining() returns 0 and therefore the StringBuffer will never have any content.
The problem seems to occur randomly and for about 20% of the clients (simulated from the same computer and therefore has the same bandwidth and so on).
Anyone knows what is going on, and how to solve the problem !?

It's always possible in any read that the number of bytes read is less than the number of bytes requested. You need to keep reading until you have got everything you expected, and cope with every possible error condition on each iteration.
EJP

Non-blocking ServerSocketChannel.accept()

This may be a dumb question, but what would the motivation be behind utilizing a non-blocking call to the accept method of the ServerSocketChannel? I'm just having a hard time thinking of any, although I'm sure there are good reasons for doing it.
Thanks,
Ken

it does seem pretty strange

Read Timeout on non-blocking sockets

Hi,
I was wondering if there is a way to specify a read timeout (like setSoTimeout for synchronous sockets) when using a non-blocking socket.
I'd like to have the select() method return is a sockets timeout expires, puting in the selected key set the timedout socket and have it's read operation return -1, something like what happens when a socket is closed by the other side.
The thing is I need this to be a timeout specific to each socket, thus the select(millis) isn't apropriate.
Anyone knows of something like this?
Thanks....

Yeah, select() is the only thing built in for that, and you have to do the bookkeeping yourself. You would start something like forming the disjunction of the ready keys and the registered keys after each select, to get the unready keys, and then looking at their history to see how long they have been unready via a Map{key,Long(time)).

About NIO non-blocking socket write method behavior

Hi all -
I hope anyone could help in this issue.
Assume you create a NIO socket and configure its channel in non blocking mode:
channel.configureBlocking(false);
then you write a byte buffer into it:
int sentBytesNum = channel.write(byteBuffer);
What are the possibilities of sentBytesNum value? I am sure of two possibilities, which are:
- all data sent so sentBytesNum equals byteBuffer data size (limit minus position before sending) (after sending the limit and position of byteBuffer are the same)
- no data is sent so sentBytesNum is zero and byteBuffer limit and postion did not change, so we shall use a write selector to test when the channel will be ready for write to write the data.
What I am not sure about and need someone to confirm is the third possibility:
- only a part of data is sent (according to the available free space of socket output buffer) so sentBytesNum is more than zero but less than data size and byteBuffer position is advanced by the value of sentBytesNum, might this possibility happen??
If yes, so we should manage to hold the non sent part of byteBuffer till the channel becomes ready for write (we can know that using write selector) so we can write it to channel???
Thanks for help,
Rocka

Yes, case three can occur. The usual NIO write loop looks like this:
int count = 0;
while (buf.position() > 0)
buf.flip();
count = ch.write(buf);
buf.compact();
if (count == 0)
break;
}This will run until buf.position() == 0 or count == 0. If the partial write case happens it will loop one more time and probably get a 0 count.
At the end of the loop, if buf.position() > 0 there is still unwritten data and at this point you should register for OP_WRITE and return to the selector. Otherwise if there is no data unwritten you should deregister OP_WRITE as you have nothing to write and aren't interested in the event any longer.
If you are reading something and writing at the same time the logic goes like this:
while (inch.read(buf) >= 0 || buf.position() > 0)
// etc
}This will read until EOF occurs and either buf.position() is zero or a zero length write occurred.

NIO non-blocking i/o- Any advantages for UDP server??

Hi,
I am developing a classic UDP-based server which serves hundreds of clients simultaneously. After receiving a simple request from a client, the server replies with a simple response (messages are no larger than 50 bytes).
What, if any non-blocking-related advantages would there be in using nio? Specifically, if I used select() without turning on non-blocking on the data channel, what do I lose?
The architecture consists of only one socket for responding to client requests. It uses receive() and send(), not read()/write()/connect().
Thanks in advance,
Dan.

>>
What, if any non-blocking-related advantageswould
there be in using nio? Specifically, if I used
select() without turning on non-blocking on thedata
channel, what do I lose?You cannot do this. The runtime will throw an
IllegalBlockingModeException when you tried to
register it.
So in order to use select(), your registered channels must
be in non-blocking mode? Why? That's just the way it is?
So to conclude, using non-blocking mode provides no real advantage for
my application. It is only required or else I would not be able to use
select(), right? If so, what is so good about nio? Can you give an example that is similar to my application which would benefit from the non-blocking characteristic of nio?
Thanks for your help so far...
Daniel.
>>
The architecture consists of only one socket for
responding to client requests. It uses receive()and
send(), not read()/write()/connect().If you are only reading from one socket there are
theoretical advantages to servicing requests on more
than one thread, but you would not use non-blocking
mode to do this.
However I think some operating systems have
performance problems when doing this. Look at this
article under accept serialization:
http://httpd.apache.org/docs/misc/perf-tuning.html
The same problems may apply to multi-thread udp socket
readers.

SO timeout relevance in non-blocking NIO ServerSocketChannel

Similar Messages

Maybe you are looking for