Wierdness with NIO socket on Solaris 2.10 part I

Question

i tried the following NioClient and MockServer, and saw some weird behavior.
1. If i run both the client and server on the same machine on Windows, the client connects to the server, queries the instrument and gets the list of instruments back.
2. if i run both client and server on the same Solaris 2.10 box, the NioClient doesn't get anything back from the MockServer, not even an ACCEPT
3. if i run the client and the server on different solaris 2.10 machines, they work fine.
have anyone seen this before? can sometone sheds some lights?
import java.net.*;
import java.io.*;
public class MockServer
     public static int counter = 2;
    public static void main(String[] args) throws IOException {
         int portNumber = Integer.parseInt(args[0]);
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(portNumber);
        } catch (IOException e) {
            System.err.println("Could not listen on port: " + portNumber);
            System.exit(1);
         System.out.println ("Listening on socket " + portNumber);
        do {             
             Socket clientSocket = null;
             try {
                 clientSocket = serverSocket.accept();
                 System.out.println ("starting a new client....");
                 MyThread mt = new MyThread (clientSocket);
                 mt.run ();
             } catch (IOException e) {
                 System.err.println("Accept failed.");
                 System.exit(1);
        while (true);
class MyThread
     private final Socket clientSocket;
     MyThread (Socket clientSocket)
          this.clientSocket = clientSocket;
     public void run ()
        new Thread (new Runnable () {
                 public void run ()
                      try
                           boolean instrumentquery = false;
                           PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                           BufferedReader in = new BufferedReader(
                                       new InputStreamReader(
                                       clientSocket.getInputStream()));
                           String inputLine;                          
                           String successoutputLine =
                                "<?xml version=\"1.0\" encoding=\"UTF-8\"?><return><returncode>success</returncode><detail>everything is good</detail></return>";
                           String failoutputLine =
                                "<?xml version=\"1.0\" encoding=\"UTF-8\"?><return><returncode>failure</returncode><detail>something is not good</detail></return>";
                           String instrumentsoutput =
                                "<?xml version=\"1.0\" encoding=\"UTF-8\"?><instruments><instrument><contract>usg-505Y</contract><cusip>12131121</cusip><deactivated>false</deactivated><halted>false</halted></instrument><instrument><contract>usg-305Y</contract><cusip>121312342</cusip><deactivated>false</deactivated><halted>false</halted></instrument></instruments>";
                           while ((inputLine = in.readLine()) != null) {
                                System.out.println ("Receiving the following" + inputLine);
                                if (inputLine.contains("queryInstrument")) instrumentquery = true;
                                if (inputLine.contains("</a>"))
                                     if (instrumentquery)
                                          instrumentquery = false;
                                          System.out.println ("Sending " + instrumentsoutput);
                                          out.println (instrumentsoutput);
                                     else
                                          if ((MockServer.counter % 2) == 0)
                                               System.out.println ("Sending " + successoutputLine);
                                               out.println(successoutputLine);
                                          else
                                               System.out.println ("Sending " + failoutputLine);
                                               out.println(failoutputLine);
                                          MockServer.counter++;
                           out.close();
                           in.close();
                           clientSocket.close();}
                      catch (Exception ex)
             }).start (); }
}please see topic "wierdness with NIO socket on Solaris 2.10 part II" for the NioClient code as the maximum per topic is 5000.

Answer 1

code for NioClient.java
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.*;
public class NioClient implements Runnable {
private InetAddress hostAddress;
private int port;
private Selector selector;
private ByteBuffer readBuffer = ByteBuffer.allocate(8192);
private List pendingChanges = new LinkedList();
private Map pendingData = new HashMap();
private Map rspHandlers = Collections.synchronizedMap(new HashMap());
public NioClient(InetAddress hostAddress, int port) throws IOException {
this.hostAddress = hostAddress;
this.port = port;
this.selector = this.initSelector();
public void send(byte[] data, RspHandler handler) throws IOException {
SocketChannel socket = this.initiateConnection();
this.rspHandlers.put(socket, handler);
synchronized (this.pendingData) {
List queue = (List) this.pendingData.get(socket);
if (queue == null) {
queue = new ArrayList();
this.pendingData.put(socket, queue);
queue.add(ByteBuffer.wrap(data));
this.selector.wakeup();
public void run() {
while (true) {
try {
synchronized (this.pendingChanges) {
Iterator changes = this.pendingChanges.iterator();
while (changes.hasNext()) {
ChangeRequest change = (ChangeRequest) changes.next();
switch (change.type) {
case ChangeRequest.CHANGEOPS:
SelectionKey key = change.socket
.keyFor(this.selector);
key.interestOps(change.ops);
break;
case ChangeRequest.REGISTER:
change.socket.register(this.selector, change.ops);
break;
this.pendingChanges.clear();
this.selector.select();
Iterator selectedKeys = this.selector.selectedKeys().iterator();
while (selectedKeys.hasNext()) {
SelectionKey key = (SelectionKey) selectedKeys.next();
selectedKeys.remove();
if (!key.isValid()) {
continue;
if (key.isConnectable()) {
this.finishConnection(key);
} else if (key.isReadable()) {
this.read(key);
} else if (key.isWritable()) {
this.write(key);
} catch (Exception e) {
e.printStackTrace();
private void read(SelectionKey key) throws IOException {
SocketChannel socketChannel = (SocketChannel) key.channel();
this.readBuffer.clear();
int numRead;
try {
numRead = socketChannel.read(this.readBuffer);
} catch (IOException e) {
key.cancel();
socketChannel.close();
return;
if (numRead == -1) {
key.channel().close();
key.cancel();
return;
this.handleResponse(socketChannel, this.readBuffer.array(), numRead);
private void handleResponse(SocketChannel socketChannel, byte[] data,
int numRead) throws IOException {
byte[] rspData = new byte[numRead];
System.arraycopy(data, 0, rspData, 0, numRead);
RspHandler handler = (RspHandler) this.rspHandlers.get(socketChannel);
if (handler.handleResponse(rspData)) {
socketChannel.close();
socketChannel.keyFor(this.selector).cancel();
private void write(SelectionKey key) throws IOException {
SocketChannel socketChannel = (SocketChannel) key.channel();
synchronized (this.pendingData) {
List queue = (List) this.pendingData.get(socketChannel);
while (!queue.isEmpty()) {
ByteBuffer buf = (ByteBuffer) queue.get(0);
socketChannel.write(buf);
if (buf.remaining() > 0) {
break;
queue.remove(0);
if (queue.isEmpty()) {
key.interestOps(SelectionKey.OP_READ);
private void finishConnection(SelectionKey key) throws IOException {
SocketChannel socketChannel = (SocketChannel) key.channel();
try {
socketChannel.finishConnect();
} catch (IOException e) {
System.out.println(e);
key.cancel();
return;
key.interestOps(SelectionKey.OP_WRITE);
private SocketChannel initiateConnection() throws IOException {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel
.connect(new InetSocketAddress(this.hostAddress, this.port));
synchronized (this.pendingChanges) {
this.pendingChanges.add(new ChangeRequest(socketChannel,
ChangeRequest.REGISTER, SelectionKey.OP_CONNECT));
return socketChannel;
private Selector initSelector() throws IOException {
return SelectorProvider.provider().openSelector();
public static void main(String[] args) {
try {
System.out.println ("the host name is " + args[0]);
NioClient client = new NioClient(
InetAddress.getByName(args[0]), 4444);
Thread t = new Thread(client);
t.setDaemon(true);
t.start();
RspHandler handler = new RspHandler();
client.send(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><a><queryInstrument/></a>\n"
.getBytes(), handler);
handler.waitForResponse();
} catch (Exception e) {
e.printStackTrace();
}