• if IO.select([@socket], nil, nil, 0) - hangs forever.
  If a timeout is added, even as little as 0.05, then the call is retried twice, and proceeds normally, continuing to use the same connection.
  e.g. IO.select(socket, nil, nil, 0.05)

Probably a good reason why timeout was 0 to begin with, but this is working as a workaround in the test cases.

Threading issue? And if we leave the timeout in place, will it come back to bite us somewhere else?

• IO.select([@socket], nil, nil, 0.05)

if(args.length > 3) {
    selector.select(timeout);
  } else {
    selector.select();
  }

The selector.select call is made with a timeout value of 0.

I recall seeing something like this in a project I worked on a few years ago, but that was in C under Solaris. As I recall, the solution had to do with retrying after EAGAIN/EWOULDBLOCK was received, but I'm not sure how that maps into NIO (which I haven't worked with).

Meanwhile, I've been using Terry Woloszyn's solution, as follows:

require 'drb'
# temporary hack to work around jruby-drb problem
module DRb
class DRbTCPSocket
  def alive?
    return false unless @socket
    if IO.select([@socket], nil, nil, 0.05)
      close
      return false
    end
    true
  end
end #DRbTCPSocket
end #DRb

• A timeout of 0 on MRI is non-blocking, whereas JRuby blocks (since Selector.select interprets 0 timeout as blocking).

• The TCP socket is buffered, and there is data in the buffer but not available on the socket.

• IOMetaClass.registerSelect ignores any buffered data (from ungotc or the inBuffer in IOHandlerNio).

(on another note, it looks like IOHandlerNio won't reliably let you 'ungotc' a zero byte because there are several checks for 'ungotc>0' which should be 'ungotc>=0')

• IOMetaClass.select_static should consider whether there is buffered data available, and do a non-blocking select and manually add to the read result array any io objects that were selected for reading and have buffered data.

• io.c:rb_f_select from MRI does this buffered check business as described above.

I made some nasty hacks to verify that fixing the above resolves the problem with drb, but I suspect it's best left to the people who properly understand the JRuby IO infrastructure to make the proper interfaces.

Hope that helps!

IOHandler.hasPendingBuffered() perhaps has to be implemented correctly for other subclasses of IOHandler (currently only IOHandlerNio).

I've not tested this very thoroughly, so it may break some other things. It does seem to fix the test case described in this issue.