Threads and blocking i/o

Question

background i am building a multi-cliented server based on the model of one thread per client. client threads wait on a BufferedReader in the run() method for data over the network and take the appropriate action based on the input.
problem a client thread needs in certains circumstances to kill the thread of another client. since the run() method loops on the blocking input of BufferedReader, any flag or call to interrupt() will not be evaluated until the BufferedReader unblocks. this is bad since it means that the client who is to be killed will not return from run() until the client app talking to the thread sends some data to unblock BufferedReader. the result is a potential dos attack against this server. bad stuff.
example the current situation: client app one connects to the server spawning Thread-1. client app two connects to the server spawning Thread-2. app two triggers killSomeClient() on Thread-1. Thread-1 continues to linger until client app 1 transmits data to the server, whereupon Thread-1 dies.
example the required functionality: app one connects to Thread-1. app two connects to Thread-2. app two triggers killSomeClient() on Thread-1. Thread-1 returns from the run() loop and the thread dies immediately.
what i've tried well, obviously, stop() and destroy() are what i really want... but that's not an option. have tried setting a flag in the while loop to be set by killSomeClient() (ie while(keepRunning && (inputFromClient = in.readLine()) != null) ). have tried interrupt() in the same manner.
potential solutions i can think of a replacement for stop() or some effective non-blocking read allowing me to loop around the reader, grabbing one char at a time and continuing the loop even if the queue is empty.
the code example this is a very pared-down version of the code showing only the material necessary for this example (better for readability!). aside from this issue, the application runs.
someClient
public class someClient{
    private Socket socket;
    private BufferedReader in;
    private String inputFromClient;
    someClient(Socket socket){
        this.socket = socket;
        this.in = new BufferedReader(new InputStreamReader(theSocket.getInputStream()));
    public void run(){
        try{
            // waits on blocking input
            while((inputFromClient = in.readLine()) != null){
                System.out.println(inputFromClient);
        }catch(Exception e){}
    public void killSomeClient(someClient killme){
        // help!!
someServer
public class someServer{
    private ServerSocket ss;
    public someServer(){
        ss = new ServerSocket(9999);
    public startServer{
        Socket socket = ss.accept();
        someClient client = new someClient(socket);
        client.start();
}

Answer 1

problem a client thread needs in certains
circumstances to kill the thread of another client.
since the run() method loops on the blocking input of
BufferedReader, any flag or call to interrupt() will
not be evaluated until the BufferedReader unblocks.In general, the best approach to terminating a blocking operation is to invalidate the object on which that operation depends. In your case, closing the socket will terminate the read().
The following is a rather lengthy piece of code that's actually been tested :-)
import java.io.*;
import java.net.*;
public class SocketStopper
    private final static int  PORTNUM = 10000;
    public static void main( String argv[] )
    throws Exception
        System.err.println("Starting server");
        Server server = new Server();
        (new Thread(server)).start();
        Thread.sleep(2000);
        System.err.println("Starting client");
        Client client = new Client();
        (new Thread(client)).start();
        Thread.sleep(2000);
        System.err.println("About to close server socket");
        server.closeSocket();
        Thread.sleep(2000);
        System.err.println("About to exit");
        System.exit(0);
    /** This object establishes a connection to the server port and then
     *  sleeps for 10 minutes without writing anything. This should cause
     *  the reader to block for input.
    public static class Client
    implements Runnable
        public void run()
            try
                Socket sock = new Socket(InetAddress.getLocalHost(), PORTNUM);
                System.err.println("Client established connection");
            catch (Exception e)
                System.err.println("Client unable to establish connection: " + e);
                return;
            try
                Thread.sleep(10 * 60000L);
            catch (InterruptedException ignored)
    /** This object sets up a server socket. It accepts the first connection
     *  from that socket and attempts to read from it, which should block.
    public static class Server
    implements Runnable
        private Socket _sock;
        public void run()
            try
                ServerSocket srv = new ServerSocket(PORTNUM);
                _sock = srv.accept();
                System.err.println("Server accepted connection");
            catch (Exception e)
                System.err.println("Server unable to receive connection: " + e);
                return;
            try
                _sock.getInputStream().read();
                System.err.println("read() completed normally");
            catch (IOException e)
                System.err.println("read() terminated with exception: " + e);
        public void closeSocket()
            try
                _sock.close();
            catch (IOException ignored)
}