Java asynchrone

Dans le langage de programmation Java, async est défini comme un appel ou une fonction qui peut être définie dans une autre fonction ou passée comme arguments dans une autre fonction qui est généralement déclarée lorsque le programme doit être exécuté sans bloquer le programme, et c'est effectué lorsque l'appel revient de l'événement et qu'il revient à la fonction de rappel. En Java, ceci est défini comme une méthode de rappel invoquée dans le thread nouvellement créé. Donc, en général, la programmation asynchrone qui n'est rien d'autre que l'écriture d'un code non bloquant qui est le programme qui est exécuté sur un thread séparé en informant le thread principal de la progression des performances, de l'achèvement de l'exécution du thread ou de son échec.

Fonctionnement de l'async en java

Dans cet article, nous aborderons une méthode de rappel connue sous le nom de fonction asynchrone en Java. Cette fonction est également connue sous le nom d'attente en Java. En Java, pour créer ou écrire une programmation asynchrone en démarrant un nouveau thread en le rendant lui-même asynchrone. Les rappels asynchrones sont utilisés uniquement lorsque les tâches ne dépendent pas les unes des autres, ce qui peut prendre un certain temps à s'exécuter. Ainsi, en général, l'appel asynchrone peut être expliqué en prenant un exemple d'achat en ligne où lorsque nous sélectionnons un article et l'ajoutons au panier, cet article ne sera pas bloqué car il sera également disponible pour d'autres là où d'autres ne le font pas. Vous n'avez pas besoin d'attendre que la commande de l'article soit terminée. Ainsi, chaque fois que nous voulons exécuter un programme pouvant être exécuté sans bloquer son exécution, cela se fait en utilisant la programmation asynchrone.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

En Java, il existe de nombreuses fonctionnalités pour écrire du code non bloquant, telles que l'utilisation de threads, de futurs, de flux, etc., car il existe de nombreuses demandes de code non bloquant où la programmation asynchrone est requise pour exécuter le code de manière asynchrone. . Discutons donc de quelques façons de réaliser une programmation asynchrone telles que les aspects jcabi, cactoos, goyave, completeableFutures, FutureTask, EA Async, etc.

1. completeableFutures

CompletableFutures est la version java des promesses javascript connue sous le nom de completeableFutures qui peut implémenter deux interfaces telles que Future et CompletionStage, où une combinaison de ces deux interfaces complète cette fonctionnalité pour écrire ou travailler avec de la programmation asynchrone. Cette fonctionnalité fournit de nombreuses méthodes telles que supplyAsync, runAsync, etc. Ces méthodes sont utilisées pour démarrer la partie asynchrone du code car la méthode supplyAsync est utilisée lorsque nous faisons quelque chose avec le résultat, et si nous ne voulons rien, nous pouvons utiliser la méthode runAsync. Il existe d'autres méthodes différentes dans completeableFutures telles que thenCompose si nous voulons utiliser plusieurs completeableFutures un après un ou en simple lorsque nous voulons utiliser des completeableFutures imbriquées et si nous voulons combiner les résultats de deux completeableFutures, alors il existe une méthode nommée méthode thenCombine. Ainsi, toutes ces méthodes sont gérées dans un futur complétable, qui à son tour a des méthodes d'étape d'achèvement qui contiennent toutes ces méthodes.

Exemple : pour créer completeableFuture à l'aide d'un constructeur sans argument en utilisant la syntaxe suivante :

CompleteableFuture <String> completeableFuture = new CompleteableFuture <String>();

Donc, pour obtenir le résultat, nous devons utiliser la méthode get(). Nous pouvons donc l'écrire comme

String result = completeableFuture.get()  où cette méthode gets () se bloquera jusqu'à ce que Future soit terminé, mais cet appel le bloquera pour toujours car Future n'est jamais terminé. Nous devons donc le compléter manuellement en appelant la méthode ci-dessous.

completeableFuture.complete("Result")

Par conséquent, les clients obtiennent des résultats spécifiés en ignorant les appels suivants. Le programme pourrait ressembler à ci-dessous.

CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
while (!completableFuture.isDone()) {
System.out.println("CompletableFuture is not finished yet...");
}
long result = completableFuture.get();

2. EA Asynchrone

Il s'agit d'une autre fonctionnalité de Java permettant d'écrire du code asynchrone de manière séquentielle, ce qui permet naturellement une programmation et des mises à l'échelle faciles. Il s'agit d'Electronic Arts qui dispose de la fonctionnalité d'attente asynchrone qui est donnée à l'écosystème Java via cette bibliothèque ea-async. Cette fonctionnalité convertit le code d'exécution et réécrit l'appel en méthode wait, qui fonctionne de la même manière que completeableFuture. Nous pouvons donc implémenter le code completeableFuture ci-dessus en utilisant la méthode EA-sync connue sous le nom de méthode wait en appelant la méthode Async.init pour initialiser le runtime Async.

Considérons donc un exemple de factorielle d'un nombre utilisant à la fois completeableFuture et EA sync.

CompletableFuture <Double> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
while (!completableFuture.isDone()) {
System.out.println("The completeableFuture is not completed...");
}
double res = completableFuture.get();

Le code ci-dessus peut donc être utilisé dans la fonctionnalité de synchronisation EA en utilisant la méthode wait pour le code ci-dessus ; au lieu de la méthode get(), nous utilisons la méthode wait() afin que le code ci-dessus puisse être mis à jour avec uniquement la dernière ligne et nous devons initialiser par la méthode init d'Async dans le bloc statique, le reste du code reste le même.

static { Async.init(); }
public func_name(){….. same as above code of completeableFuture…
double res Async.await(completableFuture);

From the above sample code, which is transformed code of completeableFuture code by using static block also for initializing the Async runtime so that the Async can transform the code of completeableFuture code during runtime and then to the await method, it can rewrite the calls which will now EA async will behave similarly to that of using the chain of completeableFuture or Future.join method. So now, when once the asynchronous execution of any method is completed, then the result from the Future method is passed to another method where the method is having the last execution using the CompleteableFuture.runAsync method.

In Java, as discussed above, there are many different ways for writing the asynchronous programming using various other methods.

Conclusion

In this article, we discussed java async where it is defined as a callback method that will continue the execution of the program without blocking by returning the calls to the callback function. This article saw how asynchronous programming is written in java using different features such as CompleteableFutures, EA async, Future Task, Guava, etc. In this article, we have seen two among these features for making the callback functions asynchronous by using various methods provided by the given respective features.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!