Oyente de extremo de subproceso. Java

Question

¿Hay algún oyente en Java que maneje que algún hilo se haya terminado? Algo como esto:

Future<String> test = workerPool.submit(new TestCalalble()); 
test.addActionListener(new ActionListener()    
    {               
    public void actionEnd(ActionEvent e)    
    {               
     txt1.setText("Button1 clicked");       
    }               
    }); 

que sé, que es imposible tratar como esto, pero quiero ser notificado cuando terminó un poco de hilo.

Normalmente utilicé esta clase de temporizador con el estado de comprobación de cada futuro. pero no es linda manera. Gracias

Answer 1

Hay CompletionService que puede usar.

CompletionService<Result> ecs 
     = new ExecutorCompletionService<Result>(e); 
ecs.submit(new TestCallable()); 
if (ecs.take().get() != null) { 
    // on finish 
} 

Otra alternativa es usar ListenableFuture de Guava.

ejemplo Código:

ListenableFuture future = Futures.makeListenable(test); 
future.addListener(new Runnable() { 
public void run() { 
    System.out.println("Operation Complete."); 
    try { 
    System.out.println("Result: " + future.get()); 
    } catch (Exception e) { 
    System.out.println("Error: " + e.message()); 
    } 
} 
}, exec); 

Personalmente, me gusta guayaba solución mejor.

Answer 2

No. Ese oyente no existe. Pero tiene 2 soluciones.

1. código Add que le notifica que el hilo se hace en el final de run() método
2. Uso Callable interfaz que devuelve un resultado de tipo Future. Puede preguntarle a Future cuál es el estado y usar el método bloqueado get() para recuperar el resultado

Answer 3

Tiene un método join() definido por la clase Thread para eso. Sin embargo, no tiene visibilidad directa de un subproceso que ejecuta su Callable en el caso de API de concurrencia.

Answer 4

Aquí hay geekish oyente. Altamente unadvisible de usar, pero, divertido e inteligente

Thread t = ... 
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler(){ 
    @Override 
    public void uncaughtException(Thread t, Throwable e) { 
     t.getThreadGroup().uncaughtException(t, e);//this is the default behaviour 
    }  
    protected void finalize() throws Throwable{ 
     //cool, we go notified 
     //handle the notification, but be worried, it's the finalizer thread w/ max priority 
    } 
}); 

El efecto puede ser a través de achived PhantomRefernce mejor

esperamos que tenga una sonrisa :)

---

Nota al margen: lo que se pide es NO thread end, pero el evento de finalización de tarea y el mejor está anulando decorateTask o afterExecute

Answer 5

Puede implementar el patrón Observer para informar la finalización.

public interface IRunComplete { 
    public void reportCompletion(String message); 
} 

Let the Thread caller implementar esta interfaz.

y en el método run() llama a este método al final. Así que ahora sabes exactamente cuándo terminará este hilo.

Pruébalo. De hecho, estoy usando esto y está funcionando bien.

Answer 6

Sin la adición de una gran cantidad de código extra que puede hacer que un oyente rápida hilo a sí mismo de la siguiente manera:

//worker thread for doings 
Thread worker = new Thread(new Runnable(){ 
    public void run(){/*work thread stuff here*/} 
}); 
worker.start(); 
//observer thread for notifications 
new Thread(new Runnable(){ 
    public void run(){ 
    try{worker.join();} 
    catch(Exception e){;} 
    finally{ /*worker is dead, do notifications.*/} 
}).start();