Esto funciona
- Se deriva de SingleThreadExecutor, pero puede adaptarlo fácilmente
- Código Java 8 lamdas, pero fácil de arreglar
Creará un ejecutor con un solo hilo, que puede realizar muchas tareas; y esperará a que el actual finalice la ejecución para comenzar con el siguiente
En caso de error o excepción de uncaugth, uncaughtExceptionHandler lo detectará
clase final pública SingleThreadExecutorWithExceptions {
public estático ExecutorService newSingleThreadExecutorWithExceptions (final Thread.UncaughtExceptionHandler uncaughtExceptionHandler) {
ThreadFactory factory = (Runnable runnable) -> {
Hilo final newThread = nuevo hilo (ejecutable, "SingleThreadExecutorWithExceptions");
newThread.setUncaughtExceptionHandler ((final Thread caugthThread, final Throwable throwable) -> {
uncaughtExceptionHandler.uncaughtException (caugthThread, throwable);
});
return newThread;
};
volver nuevo FinalizableDelegatedExecutorService
(nuevo ThreadPoolExecutor (1, 1,
0L, TimeUnit.MILLISECONDS,
nuevo LinkedBlockingQueue (),
fábrica){
vacío protegido afterExecute (Runnable runnable, Throwable throwable) {
super.afterExecute (ejecutable, arrojable);
if (arrojable == nulo && instancia ejecutable de futuro) {
tratar {
Futuro futuro = (Futuro) ejecutable;
if (future.isDone ()) {
future.get ();
}
} catch (CancellationException ce) {
arrojable = ce;
} catch (ExecutionException ee) {
arrojable = ee.getCause ();
} catch (InterruptedException es decir) {
Thread.currentThread (). Interrupt (); // ignorar / restablecer
}
}
if (arrojable! = nulo) {
uncaughtExceptionHandler.uncaughtException (Thread.currentThread (), arrojable);
}
}
});
}
clase estática privada FinalizableDelegatedExecutorService
extiende DelegatedExecutorService {
FinalizableDelegatedExecutorService (ExecutorService ejecutor) {
super (ejecutor);
}
vacío protegido finalizar () {
super.shutdown ();
}
}
/ **
* Una clase de contenedor que expone solo los métodos ExecutorService
* de una implementación de ExecutorService.
* /
clase estática privada DelegatedExecutorService extiende AbstractExecutorService {
Servicio de ejecutor final privado e;
DelegatedExecutorService (ExecutorService ejecutor) {e = executeor; }
public void execute (comando ejecutable) {e.execute (comando); }
apagado público vacío () {e.shutdown (); }
Lista pública shutdownNow () {return e.shutdownNow (); }
public boolean isShutdown () {return e.isShutdown (); }
public boolean isTerminated () {return e.isTerminated (); }
public boolean awaitTermination (tiempo de espera prolongado, unidad TimeUnit)
lanza InterruptedException {
return e.awaitTermination (tiempo de espera, unidad);
}
Envío futuro público (tarea ejecutable) {
return e.submit (tarea);
}
Envío futuro público (tarea invocable) {
return e.submit (tarea);
}
Envío futuro público (tarea ejecutable, resultado T) {
return e.submit (tarea, resultado);
}
Lista pública> invokeAll (Colección> tareas)
lanza InterruptedException {
return e.invokeAll (tareas);
}
Lista pública> invokeAll (Colección> tareas,
tiempo de espera prolongado, unidad de unidad de tiempo)
lanza InterruptedException {
return e.invokeAll (tareas, tiempo de espera, unidad);
}
public T invokeAny (Colección> tareas)
lanza InterruptedException, ExecutionException {
return e.invokeAny (tareas);
}
public T invokeAny (Colección> tareas,
tiempo de espera prolongado, unidad de unidad de tiempo)
lanza InterruptedException, ExecutionException, TimeoutException {
return e.invokeAny (tareas, tiempo de espera, unidad);
}
}
private SingleThreadExecutorWithExceptions () {}
}