Simplemente estaba explorando el paquete java.util.concurrent.

Aprendí que la clase 'Futur 'tiene un métodoboolean cancel (boolean mayInterruptIfRunning)

Por favor encuentre adjunto el código de prueba que escribí:

package com.java.util.concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;

public class FutureTester {

/**
 * @param args
 * @throws InterruptedException
 */
public static void main(String[] args) throws InterruptedException {
    // TODO Auto-generated method stub
    int poolCnt = 1;
    Callable<NumberPrinter> numberPrinter = null;
    ScheduledThreadPoolExecutor schPool = new ScheduledThreadPoolExecutor(
            poolCnt);
    ScheduledFuture<NumberPrinter>[] numPrinterFutures = new ScheduledFuture[poolCnt];
    FutureTask<NumberPrinter>[] futureTask = new FutureTask[poolCnt];

    for (int i = 0; i < poolCnt; i++) {
        numberPrinter = new NumberPrinter();
        futureTask[i] = new FutureTask<NumberPrinter>(numberPrinter);

        /*
         * numPrinterFutures[i] = (ScheduledFuture<NumberPrinter>) schPool
         * .schedule(futureTask[i], 0, TimeUnit.MILLISECONDS);
         */
        numPrinterFutures[i] = (ScheduledFuture<NumberPrinter>) schPool
                .submit(futureTask[i]);
    }

    //Thread.sleep(30);

    if (numPrinterFutures.length > 0) {

        System.out.println("Task completed ? "
                + numPrinterFutures[0].isDone());

        System.out.println("Task cancelled ? "
                + numPrinterFutures[0].cancel(true));

        System.out.println("Is task cancelled ? "
                + numPrinterFutures[0].isCancelled());
    }
}

}

class NumberPrinter implements Callable<NumberPrinter> {

private int counter = 10;

@Override
public NumberPrinter call() throws Exception {
    // TODO Auto-generated method stub

    while (counter > 0) {
        if (Thread.interrupted()) {/*OUCH !!!*/
            return null;
        }
        System.out.println("counter = " + (counter--));
    }

    return this;
}

}

Intially, asumí que cancelar una tarea también detendrá la ejecución de un hilo en ejecución la parte 'OUCH' NO incluida). Pero obtuve el resultado de la siguiente manera:

counter = 10
Task completed ? false
counter = 9
Task cancelled ? true
counter = 8
Is task cancelled ? true
counter = 7
counter = 6
counter = 5
counter = 4
counter = 3
counter = 2
counter = 1

n otras lecturas sobre stackoverflow, se dijo que

El método 'cancelar' solo puede detener los trabajos 'no iniciados' (lo que contradice la descripción de la API del método)l método de cancelación simplemente interrumpe el subproceso en ejecución que luego debe volver del método run ()

Por lo tanto, incluí la parte 'OUCH': un bucle while que verifica la interrupción; el resultado fue el siguiente:

Task completed ? false
counter = 10
Task cancelled ? true
Is task cancelled ? true

PREGUNTA:

Si se supone que uno debe escribir algo análogo a la parte 'OUCH' para detener el hilo en ejecución, ¿cuál es la utilidad / valor del método de cancelación? ¿Cómo ayuda envolver un invocable en una tarea futura si el hilo no se puede detener cancelando? ¿Cuál es la parte de diseño / conceptual / lógica que estoy pasando por alto?