Cela marche
- Il est dérivé de SingleThreadExecutor, mais vous pouvez l'adapter facilement
- Code lamdas Java 8, mais facile à corriger
Il créera un exécuteur avec un seul thread, qui peut obtenir beaucoup de tâches; et attendra la fin de l'exécution pour commencer avec la prochaine
En cas d'erreur ou d'exception, le uncaughtExceptionHandler l'attrapera
classe finale publique SingleThreadExecutorWithExceptions {
public static ExecutorService newSingleThreadExecutorWithExceptions (final Thread.UncaughtExceptionHandler uncaughtExceptionHandler) {
Usine ThreadFactory = (exécutable exécutable) -> {
Thread final newThread = nouveau Thread (exécutable, "SingleThreadExecutorWithExceptions");
newThread.setUncaughtExceptionHandler ((final Thread caugthThread, final Throwable throwable) -> {
uncaughtExceptionHandler.uncaughtException (caugthThread, throwable);
});
return newThread;
};
renvoyer un nouveau FinalizableDelegatedExecutorService
(nouveau ThreadPoolExecutor (1, 1,
0L, TimeUnit.MILLISECONDS,
nouveau LinkedBlockingQueue (),
usine){
void protégé afterExecute (Runnable runnable, Throwable throwable) {
super.afterExecute (exécutable, jetable);
if (throwable == null && runnable instanceof Future) {
essayez {
Futur futur = (Futur) exécutable;
if (future.isDone ()) {
future.get ();
}
} catch (CancellationException ce) {
jetable = ce;
} catch (ExecutionException ee) {
throwable = ee.getCause ();
} catch (InterruptedException ie) {
Thread.currentThread (). Interrupt (); // ignorer / réinitialiser
}
}
if (jetable! = null) {
uncaughtExceptionHandler.uncaughtException (Thread.currentThread (), throwable);
}
}
});
}
classe statique privée FinalizableDelegatedExecutorService
étend DelegatedExecutorService {
FinalizableDelegatedExecutorService (exécuteur ExecutorService) {
super (exécuteur testamentaire);
}
void protégé finalize () {
super.shutdown ();
}
}
/ **
* Une classe wrapper qui expose uniquement les méthodes ExecutorService
* d'une implémentation ExecutorService.
* /
classe statique privée DelegatedExecutorService étend AbstractExecutorService {
ExecutorService e privé final;
DelegatedExecutorService (exécuteur ExecutorService) {e = exécuteur; }
public void execute (commande Runnable) {e.execute (commande); }
public void shutdown () {e.shutdown (); }
liste publique shutdownNow () {return e.shutdownNow (); }
public booléen isShutdown () {return e.isShutdown (); }
public booléen isTerminated () {return e.isTerminated (); }
booléen public waitTermination (long timeout, unité TimeUnit)
lève InterruptedException {
return e.awaitTermination (timeout, unit);
}
Soumission publique future (tâche exécutable) {
return e.submit (tâche);
}
Soumission publique future (tâche appelable) {
return e.submit (tâche);
}
public Future submit (tâche exécutable, résultat T) {
return e.submit (tâche, résultat);
}
Liste publique> invokeAll (Collection> tâches)
lève InterruptedException {
return e.invokeAll (tâches);
}
Liste publique> invokeAll (Collection> tâches,
long timeout, unité TimeUnit)
lève InterruptedException {
return e.invokeAll (tâches, timeout, unité);
}
public T invokeAny (Collection> tâches)
lève InterruptedException, ExecutionException {
return e.invokeAny (tâches);
}
public T invokeAny (Collection> tâches,
long timeout, unité TimeUnit)
lève InterruptedException, ExecutionException, TimeoutException {
return e.invokeAny (tâches, timeout, unité);
}
}
SingleThreadExecutorWithExceptions () {} privé
}