views:

255

answers:

5

I am running a thread whose main action is to call on a proxy using a blocking function , and wait for it to give it something.

I've used the known pattern of a volatile boolean and the Interruption , but I'm not sure it will work: When I tried to add a catch block for "InterruptedException" , I get the error "Unreachable catch block for InterruptedException. This exception is never thrown from the try statement body"

So if I'm never going to get an InterruptedException , this means I'll never get out of the blocking action - thus will never stop.

I'm a bit puzzled. Any idea?

  public void run() {    
    Proxy proxy = ProxyFactory.generateProxy();
    Source source;

    while (!isStopped) {
      try {
        source = proxy.getPenfingSources();
        scheduleSource(source);
      } catch (Exception e) {
        log.error("UnExpected Exception caught while running",e);
      }
    }
  }

  public void stop() {
    this.isStopped = true;
    Thread.currentThread().interrupt();
  }
A: 

How are you calling stop from the executing thread?
If you call stop() from another thread, you'll kill it, not the thread running in the try/catch block.

Gazzonyx
+5  A: 

First, you don't really need a separate flag (if you do, use an AtomicBoolean), just check Thread.currentThread().isInterrupted() as your while condition.

Second, your stop method won't work because it won't interrupt the correct thread. If another thread calls stop, the code uses Thread.currentThread() which means the calling thread will be interrupted, not the running one.

Finally, what is the blocking method? Is it scheduleSource()? If that method doesn't throw InterruptedException, you won't be able to catch it.

Try the following:

private final AtomicReference<Thread> currentThread = new AtomicReference<Thread>();

public void run() {
    Proxy proxy = ProxyFactory.generateProxy();
    Source source;

    currentThread.set(Thread.currentThread());

    while (!Thread.currentThread().isInterrupted()) {
        try {
            source = proxy.getPenfingSources();
            scheduleSource(source);
        } catch (Exception e) {
            log.error("UnExpected Exception caught while running", e);
        }
    }
}

public void stop() {
    currentThread.get().interrupt();
}
Kevin
Thanks! It took me a few minutes but I've realized what I've done wrong with the "Stop". In this case , if the thread will get a "stop" request , it will stop waiting on the blocking action?
yossale
Or better just use a volatile boolean to flag the stop.
Tom Hawtin - tackline
@Tom What if scheduleSource() or proxy.getPendingSources() is blocked though? I assume he would want that call to be interrupted by stop()
Kevin
@yossale If the thread is blocked on an interruptiple action, calling stop() will interrupt it.
Kevin
@Kevin Thanks! :)
yossale
A: 

You stop method is calling interrupt on the wrong thread. Thread.currentThread() is the thread that is interrupting, not being interrupted.

Ben S
+2  A: 

Only a few, well-defined "blocking methods" are interruptible. If a thread is interrupted, a flag is set, but nothing else will happen until the thread reaches one of these well-defined interruption points.

For example, read() and write() calls are interruptible if they are invoked on streams created with a InterruptibleChannel. If a Socket is used as the starting point, calling interrupt() on a Thread blocked in the read has no effect. Note that if a blocking I/O operation is interrupted successfully, the underlying channel is closed.

Another large class of interruptible operations are those thrown by various blocking operations on classes in the java.util.concurrent packages. Of course, the original wait() method is interruptible as well.

Blocking methods can be identified by looking for a throws InterruptedException in their method signatures. They should be well-documented too, to describe any side-effects of interruption.

You can write an interruptible method of your own, but it has to be composed of interruptible lower-level operations itself.

erickson
Toward writing an interruptible method, it is, of course, possible to periodically test `Thread#interrupted()` and throw `InterruptedException` in an otherwise long-running method -- especially one involving a loop, where it's useful to test for interruption every so often if none of the methods being called within that loop are themselves interruptible.
seh
A: 

ok, people, don't kill me over this.

I experimented with Thread.stop() for fun, to kick thread out of a blocking action, catch ThreadDeath, keep target thread alive, and move on.

It seems working. The world isn't ending. But I'm just saying. You are responsible for you own doing. Why am I rapping?

irreputable