🚀 go-pugleaf

Hello

I'm having a problem at hand related to killing a thread that is currently
waiting for return from a blocking call of some other class... The code is
something like...

class MyThread extends Thread
{
    private Input input = null;
    private boolean keepRunning = true;

    MyThread (Input input) throws Exception
    {
        if (input == null) throw new Exception("Null arguments");

        this.input = input;
    }
    public run ()
    {
        while (keepRunning)
        {
            String str = input.getInput();    // a blocking method call
            // Some other code
        }
    }

    public kill ()
    {
        this.keepRunning = false;
    }
}

In the code, the class Input is an external class and it's code is not
available. We are making a call to the getInput() method which is blocking,
and it wont return unless there is some input available inside the input
object. Now assuming that the input object passed to the constructor is a
shared object in the system and getInput() is a synchronized method. This
implies that apart from my thread, there can be many other threards using
the same object.

Now I just want to kill my thread (cuz i'm no longer interesting in getting
any input from the input object). However, the input object being a shared
object will stay and the other threads in the system will still keep waiting
for an input from that object. I just want to kill MY thread. How can i do
that. In the above example, i can call the kill() method of my thread which
will set the loop invariant to false, but it wont help unless the function
call from the blocking method is returned, and the loop invariant will only
be checked afterwards. Is there a way to get the control back from a
blocking call.

Regards
Kashif