Appel asynchrone d'une méthode en Java

1. Utiliser Thread pour appeler de manière asynchrone une méthode en Java
2. Utiliser FutureTask pour appeler de manière asynchrone une méthode en Java
3. Utiliser CompletableFuture ​​pour appeler de manière asynchrone une méthode en Java
4. Utiliser EA Async pour appeler de manière asynchrone une méthode en Java
5. Utiliser la bibliothèque Cactusos pour appeler de manière asynchrone une méthode en Java

Dans cet article, nous allons apprendre à appeler une fonction en Java de manière asynchrone.

Pour commencer, nous examinerons certains des outils de programmation asynchrone intégrés de Java, tels que FutureTask et CompletableFuture. Ensuite, nous examinerons certaines bibliothèques proposant des solutions prêtes à l’emploi, telles que EA Async et Cactus.

Utiliser Thread pour appeler de manière asynchrone une méthode en Java

Nous pouvons commencer un nouveau thread pour effectuer toute action asynchrone. C’est plus simple à comprendre.

Créons un nouveau thread qui additionne deux entiers et imprime le résultat :

class example {
    public static void main(String[] args) {
        int num1 = 4;
        int num2 = 5;
        int result=num1+num2;
        Thread T = new Thread(() -> {
            System.out.println("Addition of " + num1 + " and " + num2 + " is " + result);});
        T.start();
    }
}

Utiliser FutureTask pour appeler de manière asynchrone une méthode en Java

L’interface Future vous permet d’effectuer des actions asynchrones à l’aide de la FutureTask. Nous pouvons utiliser la méthode submit du ExecutorService pour exécuter le projet de manière asynchrone et renvoyer un objet FutureTask.

Par exemple, voici comment trouver la factorielle d’un nombre :

int num1 = 9;

ExecutorService tp = Executors.newCachedThreadPool();
Future<double> futureTask = tp.submit(() -> factorial(num1));

while (!futureTask.isDone()) {
  System.out.println("Still processing the task");
}
double result = futureTask.get();
tp.shutdown();

Nous avons utilisé la fonction isDone de l’interface Future pour voir si le travail est terminé. Après cela, nous avons utilisé la méthode get pour acquérir le résultat.

Utiliser CompletableFuture ​​pour appeler de manière asynchrone une méthode en Java

En tant qu’hybride de Future et CompletionStage, CompletableFuture a été introduit dans Java 8. Il dispose de techniques de programmation asynchrones telles que supplyAsync, runAsync et thenApplyAsync.

Une CompletionStage est une promesse. Il garantit que le calcul sera terminé à un moment donné.

Le CompletionStage est utile car il fournit plusieurs méthodes pour attacher des rappels à exécuter lorsque l’étape est terminée.

Commençons par le début et faisons un simple calcul asynchrone.

Utilisez supplyAsync avec CompletableFuture pour appeler de manière asynchrone une méthode en Java

CompletableFuture.supplyAsync(this::sendMsg);

Aussi simple que cela, la fonction supplyAsync accepte un fournisseur qui contient le code asynchrone. Nous souhaitons utiliser la fonction sendMsg dans cet exemple.

Utilisez thenAccept avec CompletableFuture pour appeler de manière asynchrone une méthode en Java

CompletableFuture.supplyAsync(this::sendMsg).thenAccept(this::notify);

Dans le premier exemple, nous avons exécuté sendMsg pour envoyer un message de manière asynchrone. Ajoutons donc un rappel qui nous alertera de l’état de livraison du message.

Un rappel peut être introduit de plusieurs manières ; une façon est d’utiliser thenAccept. Il nécessite qu’un utilisateur soit notifié, dans cet exemple, pour manipuler le résultat du calcul précédent une fois fait.

Utiliser EA Async pour appeler de manière asynchrone une méthode en Java

Voici une autre fonctionnalité de Java qui vous permet d’écrire du code asynchrone pas à pas, ce qui facilite grandement la programmation et la mise à l’échelle. Electronic Arts est le créateur de la fonctionnalité async-wait, qui est disponible pour l’environnement Java via le package ea-async.

Cette fonctionnalité transforme le code d’exécution et réécrit l’appel de la méthode await, comparable à completeableFuture.

Nous pouvons donc utiliser la méthode EA-sync connue sous le nom de méthode await pour implémenter le code completeableFuture ​​ci-dessus en appelant la fonction Async.init pour initialiser le runtime Async.

Ici, nous allons utiliser la fonction await offerte par la classe Async d’EA pour modifier le code CompletableFuture ​​décrit précédemment :

static {
  Async.init();
}

Pour configurer l’analyse d’exécution Async, nous utilisons la fonction Async.init en tant que statique.

public double example2(int num1) {
  CompletableFuture<double> cf = CompletableFuture.supplyAsync(() -> factorial(num1));
  double result = Async.await(cf);
}

Au moment de l’exécution, la fonction async modifie le code et réécrit l’appel de méthode wait pour fonctionner de la même manière, en utilisant une chaîne de CompletableFuture.

Utiliser la bibliothèque Cactusos pour appeler de manière asynchrone une méthode en Java

Pour les tâches asynchrones, cette librairie propose une classe Async. La bibliothèque Cactoos possède un répertoire étendu, allant de la manipulation de texte aux structures de données.

Les types et fonctions primitifs de cette bibliothèque sont comparables à ceux fournis par d’autres bibliothèques telles que Guava et Apache Commons, bien qu’ils soient davantage axés sur les concepts de conception orientés objet.

Ici, en utilisant une instance de la classe Async de Cactus, nous allons trouver la factorielle d’un nombre.

Async<Integer, Double> a = new Async<Integer, Double>(inputdata -> factorial(inputdata));
Future<Double> asyncFuture = a.apply(num1);
Double result = asyncFuture.get();

La fonction apply utilise la méthode ExecutorService.submit pour agir et renvoyer un objet d’interface Future. La bibliothèque Cactoos propose des classes qui remplissent les mêmes fonctions que les méthodes statiques présentes dans la bibliothèque Apache Commons.