The Blocking IO Problem

Question

I would like my InputStream read operations to timeout iff they've been blocking for so long. How can I do this?
In other words, one thread is executing a read statement on an InputStream, and another thread notices that the previous thread is stalled. How can that second Thread notify the first to stop the read operation and continue on?
Non-blocking IO in 1.4 would be nice, but my clients won't have that installed. I'm using the URL class, opening a connection, and then getting the InputStream to do reads currently.
One (flawed) solution is to simply disconnect my producer (reads from the socket) and the consumer (writes to the disk) and let the blocked thread just sit there. However, the program could be used for a long period of time, and I don't like the idea of having a possible 500 blocked threads lying around.
Any and all help/information is appreciated!
NAS

Answer 1

java.net.Socket
java.net.DatagramSocket
java.net.ServerSocket
This method allows you to specify a maximum timeout length, in milliseconds, that the following network operations will block:
ServerSocket.accept()
SocketInputStream.read()
DatagramSocket.receive()
Whenever one of these methods is called, the clock starts ticking. If the operation is not blocked, it will reset and only restart once one of these methods is called again; as a result, no timeout can ever occur unless you perform a network I/O operation. The following example shows just how easy it can be to handle timeouts, without resorting to multiple threads of execution:
// Create a datagram socket on port
//2000 to listen for incoming UDP packets
DatagramSocket dgramSocket =
new DatagramSocket ( 2000 );
// Disable blocking I/O operations,
//by specifying a five second timeout
dgramSocket.setSoTimeout ( 5000 );
The following code shows how to handle a timeout operation when reading from a TCP socket:
// Set the socket timeout for ten seconds
connection.setSoTimeout (10000);
try
// Create a DataInputStream for
//reading from socket
DataInputStream din = new DataInputStream (
connection.getInputStream());
// Read data until end of data
for (;;)
String line = din.readLine();
if (line != null)
System.out.println (line);
else
break;
// Exception thrown when network timeout occurs
catch (InterruptedIOException iioe)
System.err.println (
"Remote host timed out during read operation");
// Exception thrown when general
//network I/O error occurs
catch (IOException ioe)
System.err.println ("Network I/O error -
     " + ioe);
With only a few extra lines of code for a try {} catch block, it's extremely easy to catch network timeouts.
A thread can then respond to the situation without stalling itself.
The following code shows the polling mechanism and error-handling code.
for (;;)
// Check to see if a connection is established
if (st.isConnected())
// Yes ... assign to sock variable,
//and break out of loop
sock = st.getSocket();
break;
else
// Check to see if an error occurred
if (st.isError())
// No connection could be established
throw (st.getException());
try
// Sleep for a short period of time
Thread.sleep ( POLL_DELAY );
catch (InterruptedException ie) {}
// Increment timer
timer += POLL_DELAY;
// Check to see if time limit exceeded
if (timer > delay)
// Can't connect to server
throw new InterruptedIOException
("Could not connect for " + delay +
          " milliseconds");
While the connection is regularly polled, the second thread attempts to create a new instance of java.net.Socket. Accessor methods are provided to determine the state of the connection, as well as to get the final socket connection. The SocketThread.isConnected() method returns a boolean value to indicate whether a connection has been established, and the SocketThread.getSocket() method returns a Socket. Similar methods are provided to determine if an error has occurred, and to access the exception that was caught.