Question

At some point of my server application I want to stop some threads that are performing I/O blocking operations.

For instance, one of them have the following run() method:

public void run() {
    System.out.println("GWsocket thread running");

    int len;
    byte [] buffer = new byte[1500];
    try {
        this.in  = new DataInputStream(this.socket.getInputStream());
        this.out = new DataOutputStream(this.socket.getOutputStream());
        running = true;

        while (running){
            len = in.read (buffer);
            if (len < 0)
                running = false;
            else
                parsepacket (buffer, len);
        }

    }catch (IOException ex) {
        System.out.println("GWsocket catch IOException: "+ex);
    }finally{
        try {
            System.out.println("Closing GWsocket");
            fireSocketClosure();
            in.close();
            out.close();
            socket.close();
        }catch (IOException ex) {
            System.out.println("GWsocket finally IOException: "+ex);
        }
    }
}

If I Want to stop a thread running this code, what should I do?

Here they show how to do (How do I stop a thread that waits for long periods (e.g., for input)?), but I don’t understand what they mean with:

For this technique to work, it’s critical that any method that catches
an interrupt exception and is not prepared to deal with it immediately
reasserts the exception. We say reasserts rather than rethrows,
because it is not always possible to rethrow the exception. If the
method that catches the InterruptedException is not declared to throw
this (checked) exception, then it should “reinterrupt itself” with the
following incantation: Thread.currentThread().interrupt();

Can anyone give me some hints? Some code examples would be very appreciated.

Answer 1

A solution, described by Peter Lawrey and also seen here is to close the socket.

With nio, You could also use a SocketChannel which is interruptible and would allow the application of the standard interrupt model of Java.

A call to the interrupt method of your Thread object would throw an InterruptedException which would stop even your blocking IO operation.