Sockets behave differently on Windows

Question

I am writing a program that communicates from C to Java via a socket. The C program forks and execs the Java program. That way I can do the GUI in a platform-independent manner. It works great in OS X and Linux. But when I try it in Windows (using the Windows sockets and spawnlp), the Java half of the program sits there using 100% cpu until I close the socket. I do not get this cpu usage on the other platforms.
Surely Java in Windows does not poll the socket? So what could cause this?
Here is my socket class:
* PlayServer.java
* Created on February 18, 2007, 5:39 PM
* This class creates a socket server to listen for TKF input
* Author: James A. Rome
* All incoming commands are terminated by a #
* This Socket server understands certain commands:
* Incoming commands:
* #f filepath The name of the tkf file to use as an input source
* #c closes the socket
* Outgoing commands:
package com.sciend.tekplot;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;
* @author jar
public class GpcSocketServer {
private transient ServerSocket server;
private transient Socket socket;
private transient InputStream in;
private transient OutputStream out;
private static String str = "OK" ;
private transient Vector<InputData> data = new Vector();
protected final int BEFORE = 0;
protected final int GOT_TYPE = 1;
protected final int IN_MESSAGE = 2;
protected final int DONE = 4;
private volatile Thread t;
private volatile ReadSocket r;
/** Creates a new instance of GpcSocketServer on the default port */
public GpcSocketServer() {
startServer(9999); //default port
* Creates a new instance of GpcSocketServer on the given port
public GpcSocketServer(int port) {
startServer(port);
private void startServer(int port) {
try {
server = new ServerSocket(port);
socket = server.accept();
setIn(socket.getInputStream());
setOut(socket.getOutputStream());
// Send an OK to the client
getOut().write(str.getBytes());
// We next need to start the socket reader
r = new ReadSocket();
t = new Thread(r);
t.start();
} catch (IOException ex) {
ex.printStackTrace();
* Stop the socket server
public void stopServer() {
System.err.println("Stopping Java socket");
try {
r.cancel();
server.close();
catch (IOException e) {
e.printStackTrace();
* Get the last piece of data
public InputData getLastData() {
int size = getData().size();
return getData().get(size - 1);
* Get the first data of type t
* @param t - the code for the data type
public InputData getFirstDataType(char t) {
int size = getData().size();
for(int i = 0; i < size; i++) {
if(getData().get(i).getMessageType() == t) {
return getData().get(i);
return null;
* Get the last data of type t
* @param t - the code for the data type
public InputData getLastDataType(char t) {
int size = getData().size();
for(int i = size-1; i >= 0; i++) {
if(getData().get(i).getMessageType() == t) {
if(t == 'c') { //turn off socket
stopServer();
return getData().get(i);
return null;
* A class to read the socket input and to put it into a Vector
private class ReadSocket implements Runnable {
ReadSocket() {
public void run() {
int count = 0;
int msgCount = 0;
char type = '\0';
int nHashes = 0;
int state = 0;
int bp = 0; //buffer pointer
byte ch;
char chr;
String msg = "";
try {
try {
while (!Thread.currentThread().isInterrupted() ) {
if( (count = getIn().available()) > 0) {
// make array bigger than count in case more bytes are added between these steps
byte[] buffer = new byte[2* count ];
bp = 0;
// read the contents
count = getIn().read(buffer);
do {
switch(state) {
case BEFORE:
if(nHashes == 0) {   // read to the hash
while((ch = buffer[bp]) != '#') {
bp++;
if(bp == count)
break;
nHashes = 1;
bp++;
} else {
ch = buffer[bp++];
chr = (char)ch;
type = chr;
state = GOT_TYPE;
if(bp == count)
break;
break;
case GOT_TYPE:
// Toss any spaces before the message body
while((buffer[bp]) == ' ') {
bp++;
if(bp == count)
break;
state = IN_MESSAGE;
break;
case IN_MESSAGE:
while(true) {
ch = buffer[bp];
chr = (char)ch;
if(ch == '#') {
// end of message
state = DONE;
// create the new data structure
InputData id = new InputData();
id.setMessageCount(msgCount++);
id.setMessageType(type);
id.setMessage(msg);
// reset states and variables for new message
state = BEFORE;
msg = "";
type = '\0';
nHashes = 0;
getData().add(id); // Add it to the Vector.
bp++;
break;
} else {
msg = msg + chr;
bp++;
if(bp == count)
break;
break;
} while(bp < count);
Thread.sleep(1000);
} // end while(true)
} catch (IOException ex) {
ex.printStackTrace();
} catch(InterruptedException e) {
} // End of run
public void cancel() {
t.interrupt();
} // End ReadSocket
public InputStream getIn() {
return in;
public void setIn(InputStream in) {
this.in = in;
public OutputStream getOut() {
return out;
public void setOut(OutputStream out) {
this.out = out;
public Vector<InputData> getData() {
return data;
public void setData(Vector<InputData> data) {
this.data = data;
}

Answer 1

Use a BufferedInputStream around the socket input stream.
I'm not a fan of polling available() and sleeping. You're much better off using an appropriately sized buffer to start with and just calling read() and letting it decide when data is available. Consider the degenerate case where one byte at a time arrives 50ms apart. Your code will run 20 times as slowly as a simple read() call that blocks only until data is really there.