Re: FutureTask.cancel() - can anyone explain the mechanism?
On Sep 17, 3:32 pm, markspace <nos...@nowhere.com> wrote:
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 ArrayBlockingQ=
ueue( 2 );
static ExecutorService es = Executors.newSingleThreadExecuto=
r();
public static void main( String[] args ) throws InterruptedExc=
eption {
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 = (Stri=
ng) 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;
}
}
}- Hide quoted text -
- Show quoted text -
Thanks for your reply.
SSCCE and output provided.
package example;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
public class FutureTaskCancelExample {
private static class MyCallable implements Callable<Integer> {
private final BlockingQueue<String> blockingQueue = new
LinkedBlockingQueue<String>();
public void put(final String message) {
try {
this.blockingQueue.put(message);
}
catch (Throwable t) {
System.out.println("Throwable caught in put()" + t.getCause
().getMessage());
}
}
public Integer call() {
try {
while(true) {
final String message = this.blockingQueue.take();
System.out.println(message);
}
}
catch (Throwable t) {
System.out.println("Throwable caught in call() " + t.getCause
().getMessage());
}
finally {
System.out.println("Entered call() finally block.");
}
return new Integer((int)0);
}
}
public static void main(String[] args) {
final ExecutorService executor = Executors.newSingleThreadExecutor
();
final MyCallable myCallable = new MyCallable();
final Future<?> myFuture = executor.submit(myCallable);
myCallable.put("Go Southend United FC!");
myFuture.cancel(true);
executor.shutdown();
}
}
Output:
Go Southend United FC!
Entered call() finally block.