Por lo tanto, este recurso (http://www.ibm.com/developerworks/java/library/j-jtp05236/index.html) sugiere establecer el bit de interrupción en un subproceso cuando ese subproceso no se ocupa de la interrupción en sí misma, "para que el código que se encuentra en la parte superior de la pila de llamadas pueda conocer la interrupción y responder si lo desea.. "

Digamos que estoy usando un ExecutorService para ejecutar algo en un subproceso diferente. Construyo un Callable y paso este Callable a ExecutorService.submit (), que devuelve un Future. Si el Callable se interrumpe y luego restablece el bit de interrupción, el Futuro asociado no lanzará una InterruptedException cuando se llame a Future.get (). Entonces, ¿cuál sería el propósito de establecer el bit interrumpido en el callable si este futuro es la única forma en que el hilo principal tiene acceso al hilo generado?

class MyCallable implements Callable<String> {
  @Override
  public String call() {
    while (!Thread.currentThread().isInterrupted()) {
    }
    Thread.currentThread().interrupt();
    return "blah";
  }
}

 ExecutorService pool = makeService();
 Future<String> future = pool.submit(new MyCallable());
 // Callable gets interrupted and the Callable resets the interrupt bit.
 future.get(); // Does not thrown an InterruptedException, so how will I ever know that the Callable was interrupted?