¿Por qué Java Future.get (timeout) no es confiable?

Question

Future.get (timeout) no arroja confiablemente TimeoutException después del tiempo de espera dado. ¿Es este comportamiento normal o puedo hacer algo para que esto sea más confiable? Esta prueba falla en mi máquina. Sin embargo, si duermo durante 3000 en lugar de 2000, pasará.

public class FutureTimeoutTest { 
@Test 
public void test() throws 
    ExecutionException, 
    InterruptedException { 

    ExecutorService exec = Executors.newSingleThreadExecutor(); 
    final Callable call = new Callable() { 
     @Override 
     public Object call() throws Exception { 
      try { 
       Thread.sleep(2000); 
      } catch (InterruptedException ex) { 
       ex.printStackTrace(); 
      } 
      return 0; 
     } 
    }; 
    final Future future = exec.submit(call); 
    try { 
     future.get(1000, TimeUnit.MILLISECONDS); 
     fail("expected TimeoutException"); 
    } catch (TimeoutException ignore) { 
    } 
} 

}

Answer 1

No hay ninguna razón para esperar que la prueba pase. Dado que envía la tarea para su ejecución y espera a que se complete, puede pasar cualquier cantidad de tiempo antes de que comience la espera en Future#get(), lo que permite que la tarea tarde un montón en agotar la duración del sueño y finalizar.

En su caso, podemos suponer que el subproceso que se ejecuta dentro del Executor obtiene foco mientras que el subproceso principal que se ejecuta en test() está en espera, a pesar de estar en estado ejecutable. En cuanto a la diferencia observada entre el bloqueo de la tarea enviada durante dos y tres segundos, espero que puedas encontrar situaciones en las que incluso tres segundos sean insuficientes, dependiendo de lo que estén haciendo otros procesos en tu computadora.

Answer 2

@seh tiene razón.

Usted está contando con lo que comúnmente se denomina comportamiento "en tiempo real" de Java. Esto no se puede lograr de manera confiable a menos que use bibliotecas en tiempo real en una distribución Java capaz en tiempo real que se ejecute en un sistema operativo en tiempo real.

Sólo para ilustrar, la implementación de hilos de Java en las JVM modernas como HotSpot se basa en programador de subprocesos nativo del sistema operativo host para decidir qué temas se ejecute cuando. A menos que el programador de hilos esté específicamente al tanto de los plazos y cosas en tiempo real, es probable que tome una vista de "todo el sistema" al decidir qué hilos ejecutar. Si el sistema está cargado, es posible que ningún subproceso en particular se programe para ejecutarse durante segundos ... o más ... después de que hayan pasado las condiciones que impidieron su ejecución (por ejemplo, la espera de un evento del temporizador).

Luego está el problema de que el Java GC puede causar todos los otros hilos para bloquear.

Si realmente necesita el comportamiento en tiempo real a partir de Java, que está disponible. Por ejemplo:

• La página Sun Java Real-Time System.
• La página de Wikipedia Real time Java.

Sin embargo, debe esperar cambiar sus aplicaciones para utilizar diferentes API para darle un comportamiento en tiempo real.

Answer 3

Tengo que decir, creo que los otros dos respuestas actualmente tienen una opinión innecesariamente baja concurrencia de las clases Java. No le darán una precisión de milisegundos (lo que esperan las aplicaciones "reales" en tiempo real), pero generalmente funcionan bastante bien. He escrito servicios comerciales a gran escala utilizando Futures and Executors y normalmente trabajaron en 10 milisegundos de los tiempos esperados, incluso bajo carga.

He corrido esta prueba, tanto en MacOS 10.6 con Java 1.6 y WinXP w/Java 1.6.0_22 y ambos funcionan como se esperaba.

he modificado el código de la siguiente manera para probar la exactitud:

long time1 = System.nanoTime(); 

    System.out.println("Submitting"); 
    final Future<Object> future = exec.submit(call); 
    try { 
     future.get(1000, TimeUnit.MILLISECONDS); 

     long time2 = System.nanoTime(); 
     System.out.println("No timeout after " + 
          (time2-time1)/1000000000.0 + " seconds"); 

     fail("expected TimeoutException"); 
    } catch (TimeoutException ignore) { 
     long time2 = System.nanoTime(); 
     System.out.println("Timed out after " + 
          (time2-time1)/1000000000.0 + " seconds"); 
    } 
    finally { 
     exec.shutdown(); 
    } 

En este XP imprime "cronometrados después de 1.002598934 segundos" y en lo imprime MacOS X 'cronometrados después 1.003158 segundos'.

Si el cartel original describiría su sistema operativo y la versión de JDK, tal vez podríamos determinar si se trata de un error en particular.