API Asynchrones en Java 8

#J8Async @JosePaumard
Asynchrone ?

AsynchroneAsynchrone
• Trois tâches à exécuter
T1
T2
T3

• 1ère façon de faire :
« exécution synchrone »

• 2ème façon de faire :
« exécution multithread »

« exécution multithread » … sur un seul cœur

« asynchrone »

« asynchrone » … même sur un multicœur

• Plus rapide ?

• Plus rapide ?
 En général oui
 Approche « non blocking »

• Différence avec le modèle synchrone multithread ?
1) Le traitement décide de passer d’une tâche à l’autre
2) Pas de problème d’atomicité / visibilité
• Performances ?
 Pas de « context switch »

• Pattern
queryEngine.select("select user from User")
.forEach(user ‐> System.out.prinln(user)) ;

• Pattern
• Callback ou tâche : lambda expression
.forEach(user ‐> System.out.prinln(user)) ;

• Pattern
• Enchaînement : lorsque le résultat est disponible
alors on enchaîne avec le traitement
.forEach(System.out::prinln) ;

• Pattern
• Enchaînement : lorsque le résultat est disponible
alors on enchaîne avec le traitement
• Comment écrire ceci en Java ?
.forEach(System.out::prinln) ;

Notion de tâcheNotion de tâche
• Depuis Java 1 : Runnable
• Java 5 : Callable
• Java 5 : ExecutorService (pool de threads)
• On donne une tâche, on récupère un Future

• Pattern
Callable<String> task = () ‐> "select user from User" ;
Future<String> future = executorService.submit(task) ;

• Pattern
List<User> users = future.get() ; // blocking
users.forEach(System.out::println) ;

• Pattern
• Le passage d’un objet d’une tâche à l’autre se fait
dans le thread « maître »
List<User> users = future.get() ; // blocking
users.forEach(System.out::println) ;

Programmation asynchroneProgrammation asynchrone
• Nouveaux outils en Java 8 pour traiter ce point
• Solution pour enchaîner les tâches
• Asynchrone & multithread

Questions ?
#J8Async
Questions ?
#J8Async

• Nouvelle interface en Java 8 : CompletionStage
De quoi s’agit-il ?De quoi s’agit-il ?
/**
* A stage of a possibly asynchronous computation, that performs an
* action or computes a value when another CompletionStage completes.
* A stage completes upon termination of its computation, but this may
* in turn trigger other dependent stages.
*/

• Nouvelle interface en Java 8 : CompletionStage
• CompletionStage = une tâche qui se déclenche sur
une autre et qui peut en déclencher d’autres
/**
* A stage of a possibly asynchronous computation, that performs an
* action or computes a value when another CompletionStage completes.
* A stage completes upon termination of its computation, but this may
* in turn trigger other dependent stages
*/

• Classe d’implémentation : CompletableFuture
• Implémente à la fois :
 Future
 CompletionStage

• CompletableFuture : modélise une tâche
• Peut être dans trois états :

 En train d’être calculée

 Calculée, ayant produit un résultat

 Calculée, ayant produit un résultat
 Calculée, ayant généré une exception

FutureFuture
• Cinq méthodes :
boolean cancel(boolean mayInterruptIfRunning) ;

FutureFuture
boolean isCanceled() ;
boolean isDone() ;

FutureFuture
boolean isCanceled() ;
boolean isDone() ;
V get() ; // blocking call
V get(long timeout, TimeUnit timeUnit) ; // may throw a checked exception
throws InterruptedException, ExecutionException, TimeoutException ;

CompletableFutureCompletableFuture
• Méthodes de type « future » :
V join() ; // may throw an unchecked exception
V getNow(V valueIfAbsent) ; // returns immediately

boolean complete(V value) ; // sets the returned value is not returned
void obtrudeValue(V value) ; // resets the returned value

boolean complete(V value) ; // sets the returned value is not returned
void obtrudeValue(V value) ; // resets the returned value
boolean completeExceptionnaly(Throwable t) ; // sets an exception
void obtrudeException(Throwable t) ; // resets with an exception

Création d’un CompletableFutureCréation d’un CompletableFuture
• CompletableFuture déjà terminé
public static CompletableFuture completedFuture(U value) ;

Création d’un CompletableFutureCréation d’un CompletableFuture
• CompletableFuture déjà terminé
public static CompletableFuture completedFuture(U value) ;
public static CompletableFuture
supplyAsync(Supplier value, Executor executor) ;
public static CompletableFuture
runAsync(Runnable runnable, Executor executor) ;

CompletionStageCompletionStage
• Concept : un étape dans un traitement global
 Peut être déclenchée par une étape précédente
 Peut déclencher d’autres étapes
 Peut être exécutée dans un executor particulier

CompletionStageCompletionStage
• Notion tâche :
 Function : prend un argument, retourne une valeur
 Consumer : prend un argument
 Runnable
= interfaces fonctionnelles, donc lambda

CompletionStage – chaînageCompletionStage – chaînage
• Chaînage après, même thread
public CompletionStage
thenApply(Function<? super T,? extends U> fn);
public CompletionStage<Void>
thenAccept(Consumer<? super T> action);
thenRun(Runnable action);

• Chaînage après, autre thread (common FJ pool)
thenApplyAsync(Function<? super T,? extends U> fn);
thenAcceptAsync(Consumer<? super T> action);
thenRunAsync(Runnable action);

• Chaînage après, autre thread (executor)
thenApplyAsync(Function<? super T,? extends U> fn, Executor executor);
thenAcceptAsync(Consumer<? super T> action, Executor executor);
thenRunAsync(Runnable action, Executor executor);

CompletionStage – compositionCompletionStage – composition
• Composition
thenCompose(Function<? super T, ? extends CompletionStage> fn);
thenComposeAsync(
Function<? super T, ? extends CompletionStage> fn);
thenComposeAsync(
Function<? super T, ? extends CompletionStage> fn,
Executor executor);

Chaînage & compositionChaînage & composition
• Ces deux familles de fonction permettent d’enchaîner
une opération après l’autre

• On peut aussi enchaîner une tâche à la suite de deux
autres tâches
public CompletionStage<V> thenCombine
(CompletionStage other,
BiFunction<T, U, V> function) ;

autres tâches
• Prend les résultats de this et other
 Et les combine dans function

autres tâches
public CompletionStage<V> thenCombineAsync

autres tâches
public CompletionStage<V> thenCombineAsync
BiFunction<T, U, V> function, Executor executor) ;

• Versions avec Consumer
public CompletionStage<Void> thenAcceptBoth
BiConsumer<T, U> action) ;
public CompletionStage<Void> thenAcceptBothAsync
BiConsumer<T, U> action) ;
public CompletionStage<Void> thenAcceptBothAsync
BiConsumer<T, U> action, Executor executor) ;

• Versions avec Runnable
public CompletionStage<Void> runAfterBoth
(CompletionStage<?> other,
Runnable action) ;
public CompletionStage<Void> runAfterBothAsync
Runnable action) ;
public CompletionStage<Void> runAfterBothAsync
Runnable action, Executor executor) ;

• Ces tâches se déclenchent conditionnellement à this
et à la tâche passée en paramètre
• Lorsque ces tâches sont terminées
• On peut aussi déclencher lorsque la première se
termine

Chaînage multipleChaînage multiple
• Version function
public CompletionStage<V> applyToEither
(CompletionStage<? extends T> other,
Function<T, U> function) ;

• Version function
public CompletionStage applyToEither
public CompletionStage applyToEitherAsync
public CompletionStage applyToEitherAsync
Function<T, U> function, Executor executor) ;

• Version consumer
public CompletionStage<V> acceptEither
Consumer<? extends T> consumer) ;
public CompletionStage<V> acceptEitherAsync
Consumer<? extends T> consumer) ;
public CompletionStage<V> acceptEitherAsync
Consumer<? extends T> consumer, Executor executor) ;

• Version runnable
public CompletionStage<V> runAfterEither
Runnable action) ;
public CompletionStage<V> runAfterEitherAsync
Runnable action) ;
public CompletionStage<V> runAfterEitherAsync
Runnable action, Executor executor) ;

Création sur plusieurs tâchesCréation sur plusieurs tâches
• Méthodes statiques
public static CompletableFuture<Void>
allOf(CompletableFuture<?>... cfs) ;
public static CompletableFuture<Object>
anyOf(CompletableFuture<?>... cfs) ;

• Attention à la sémantique !
• Imprime « null »
CompletableFuture<Void> allOf = CompletableFuture.allOf() ;
System.out.println("allOF : " + allOf.join()) ;

• Ne rend pas la main…
CompletableFuture<Object> anyOf = CompletableFuture.anyOf() ;
System.out.println("anyOf : " + anyOf.join()) ;

CompletableFuture<Object> anyOf = CompletableFuture.anyOf() ;
System.out.println("anyOf : " + anyOf.getNow("Nothing to say")) ;

Gestion des exceptionsGestion des exceptions
• Point délicat :
 Une première étape consiste à créer les tâches et à
décrire leur enchaînement
 L’exécution des tâches démarre indépendamment des
appels
 À chaque étape, un CompletableFuture est créé

• Un CompletableFuture peut dépendre :
 Cas 1 : d’un autre CompletableFuture
 Cas 2 : de deux autres CompletableFuture
 Cas 3 : de N CompletableFuture

• Une exception est jetée dans le cas 1
 Tous les CompletableFuture sont en erreur
• Ils se terminent « exceptionnellement »
 isExceptionnaly() retourne true
 L’appel à get() jette une ExecutionException
 get().getCause() retourne l’exception première

 Tous les CompletableFuture en aval sont en erreur
• Ils se terminent « exceptionnellement »
• L’autre tâche peut se terminer normalement
 On peut l’interroger par get() pour avoir son résultat

 Le CompletableFuture retourné est en erreur
• Il se termine « exceptionnellement »
• Les autres tâches peuvent se terminer normalement
 On peut l’interroger par get() pour avoir son résultat

• On peut aussi traiter une exception normalement
 Dans ce cas, l’exception est passée à la fonction
 Utile pour les checked exception
CompletionStage<T> exceptionally(
Function<Throwable, ? extends T> function);

• Méthode whenComplete()
 Dans ce cas t ou e est nul dans l’appel de action
 Le CompletableFuture retourné peut ne pas être en
erreur
CompletionStage<T> whenComplete
(BiConsumer<T, Throwable> action) ;

• Méthode whenComplete()
CompletionStage<T> whenComplete
CompletionStage<T> whenCompleteAsync
CompletionStage<T> whenCompleteAsync
(BiConsumer<T, Throwable> action, Executor executor) ;

• Méthode handle()
 Dans ce cas t ou e est nul dans l’appel de function
 Retourne un CompletableFuture qui peut ne pas être
en erreur
CompletionStage<T> handle
(BiFunction<T, Throwable, U> function) ;

• Méthode handle()
CompletionStage<T> handle
CompletionStage<T> handleAsync
CompletionStage<T> handleAsync
(BiFunction<T, Throwable, U> function, Executor executor) ;

Une dernière méthodeUne dernière méthode
• CompletableFuture : On peut obtenir une estimation
du nombre de tâches qui attendent l’exécution d’une
tâche donnée
int getNumberOfDependents() ;

Exemple – 1Exemple – 1
• Lecture asynchrone de liens et affichage
CompletableFuture.supplyAsync(
() ‐> readPage("http://whatever.com/")
)

)
.thenApply(page ‐> linkParser.getLinks(page))

)
.thenAccept(
links ‐> displayPanel.display(links)
) ;

)
.thenAcceptAsync(
links ‐> displayPanel.display(links),
executor
) ;

public interface Executor {
void execute(Runnable command);
}

public interface Executor {
void execute(Runnable command);
}
Executor executor = runnable ‐> SwingUtilities.invokeLater(runnable) ;

)
.thenAcceptAsync(
links ‐> displayPanel.display(links),
runnable ‐> SwingUtilities.invokeLater(runnable)
) ;

)
.thenApply(Parser::getLinks)
.thenAcceptAsync(
DisplayPanel::display,
SwingUtilities::invokeLater
) ;

• Événements asynchrones dans CDI
@Inject
Event<String> event ;
event.fire("some event") ; // returns void
public void observes(@Observes String payload) {
// handle the event, called in the firing thread
}

// handle the event, called in the firing thread
CompletableFuture.anyOf(/* some task */) ;
}

@Inject
event.fireAsync("some event") ; // returns CompletableFuture<Object> (?)
// handle the event in another thread
}

@Inject
event.fireAsync("some event", executor) ;
// handle the event in the executor
}

@Inject
@Produces @SwingExecutor
Executor executor = SwingUtilities::invokeLater
public void observes(@Observes String payload,
@SwingExecutor Executor executor) {
// handle the event in the Swing thread
}

@Inject
@Produces @SwingExecutor
Executor executor = SwingUtilities::invokeLater
public void observes(@Observes @SwingExecutor String payload) {
// handle the event in the Swing thread
}

CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
CompletableFuture<String> reduce =
manyStrings
.onClose(() ‐> { closing.complete("Closed") ; })
.map(CompletableFuture::completedFuture)
.reduce(
closing,
(cf1, cf2) ‐> cf1.thenCombine(cf2, function) // concatenation
) ;
manyStrings.close() ;

L’indispensable !L’indispensable !
• Fixer la taille du Common Fork / Join Pool
System.setProperty(
"java.util.concurrent.ForkJoinPool.common.parallelism", 2) ;

ConclusionConclusion
• On a une API pour le calcul asynchrone dans le JDK !

• Très riche et souple à l’utilisation

• Construite sur l’utilisation des lambda

• Permet un contrôle fin des threads

• Gère différents types de chaînage

• Gère différents types de chaînage
• Gère intelligemment les exceptions

API Asynchrones en Java 8

More Related Content

What's hot

Viewers also liked

More from José Paumard

Recently uploaded

API Asynchrones en Java 8