Re: FutureTask.cancel() - can anyone explain the mechanism?
The Dude wrote:
If I invoke futureTask.cancel() I can see that I jump straight to the
finally clause of my call() method. No exceptions appear to be thrown.
In my test, both the catch and the finally where executed, in that order.
Can you produce a more complete example that exhibits the behavior? An
SSCCE is necessary here, I think.
2. If this is a safe mechanism for stopping my consumer thread.
Sure, if you can implement it correctly.
3. If this is safe can I submit a Runnable instead of a callable and
safely cancel the Thread this way?
Same answer as #2 above.
For reference, my quick test was:
package fubar;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutureTest
{
static ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue( 2 );
static ExecutorService es = Executors.newSingleThreadExecutor();
public static void main( String[] args ) throws InterruptedException {
new Thread( new Producer() ).start();
Future future = es.submit( new Consumer() );
Thread.sleep( 1000 );
future.cancel( true );
}
static class Producer implements Runnable {
int loopCount;
// Called from producer thread.
public void addMessage( final String message ) {
try {
blockingQueue.put( message );
}catch( InterruptedException ie ) {
// Log exception
}
}
public void run() {
for( ;; ) {
addMessage( "Test " + ++loopCount );
}
}
}
// Implement Callable<Integer>
// Consume messages from blocking queue
static class Consumer implements Callable {
public Integer call() {
try {
while( true ) {
final String message = (String) blockingQueue.take();
}
}catch( Throwable t ) {
System.out.println( "caught: "+ t );
// log Throwable
}finally {
System.out.println( "Stopped." );
// Log that Thread has been cancelled/stopped
}
return 0;
}
}
}