Attente asynchrone Java

Java Asynchronous wait est défini comme effectuant des opérations liées aux E/S et ne nécessite aucune réactivité de l'application. Ces fonctions sont normalement utilisées dans les opérations sur les fichiers et le réseau car elles nécessitent des rappels exécutés à la fin de l'opération ; aussi que cette fonction renvoie toujours une valeur. À l'aide du mot-clé awake, les appels asynchrones sont utilisés dans les instructions de flux de contrôle régulières et il s'agit d'un code non bloquant. Dans cette rubrique, nous allons en apprendre davantage sur l'attente asynchrone Java.

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

Syntaxe

La signature générale de async / wait est donnée comme

async void test() {
print('Welcome to EDUCBA');
}

L'attente continue comme

const test=async() =>
{
await test ();
Print ("completed");
}

Comment fonctionne la fonction d'attente asynchrone en Java ?

La fonction Async waits permet d'écrire du code synchrone tout en effectuant des tâches asynchrones derrière le code. Et nous avons besoin du mot-clé async. Et vient ensuite la partie attendue qui dit d'exécuter le code asynchrone normalement et de passer à la ligne de code suivante. Le nouvel opérateur « Attendre » attend automatiquement une promesse pour résoudre le processus en cours lorsqu'il est utilisé dans une fonction asynchrone. Cependant, cela provoque des erreurs de syntaxe lorsqu'il est utilisé dans un autre cas.

Si la fonction génère une erreur dans la gestion des erreurs, la promesse de la fonction asynchrone sera rejetée. Si la fonction respective renvoie une valeur, la promesse sera résolue. Ce code non bloquant s'exécute sur un thread distinct et informe le thread principal de l'achèvement ou de l'échec d'une tâche. Try-catch est utilisé dans une fonction pour gérer les erreurs de manière synchrone. Prenons un échantillon commençant comme

async function hello() {
//process waiting
await new Promise(res => setTimeout(res, 2000));
// Rejection with 20 %
if (Math.random() > 0.2) {
throw new Error('Check the number.')
}
return 'number';
}

Le code ci-dessus indique que la fonction hello() est asynchrone, la résout en renvoyant un nombre et renvoie une erreur en vérifiant le numéro.

Ensuite, utilisez wait et return ensemble pour suspendre un processus

async function miss() {
try {
return await hello();
} catch (e) {
return 'error caught';
}
}

Un chaînage plus prometteur avec cette fonction est donné comme

async function promise1( req,res)
{
try
{
let a=await a.get(req,uid);
let b=await cart.get (yser,uid);
Res.send(await dosome(a,cart));
}
catch (err)
{
res.send(err);
}
}

Donc, ici, le mot-clé wait demande à la fonction get () de se terminer avant de détecter une erreur.

Avec ce futur Completable, il renvoie un objet futur. Ce futur Completable fait référence au calcul asynchrone et implémente le futur.

private static CompletableFuture<Void> hello{
try {
String intermediate = await(doA());
String res = await(doB(intermediate));
reportSuccess(res);
} catch (Throwable th) {
reportFailure(th);
}
return completedFuture(null);
}

Exemples d'attente asynchrone Java

Donc, dans cette section, nous verrons comment les subtilités de l'async et de l'attente fonctionnent ici.

Exemple n°1

Code :

import 'dart:async';
void main() async {
var a = await ten();
print(a);
}
Future<int> ten() async {
return 10;
}

Explication

Le code ci-dessus utilise le futur, l'API de la version Java 7, et attend dix secondes pour afficher 10.

Sortie :

Exemple n°2

Code :

import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
class Comput1 implements Runnable
{
public static int item = 0;
public void run()
{
item = 3 * 3;
try
{
CyclicBarrierAwaitExample2.newBarrier.await();
}
catch (InterruptedException | BrokenBarrierException e)
{
e.printStackTrace();
}
}
}
class Comput2 implements Runnable
{
public static int total = 0;
public void run()
{
// check if newBarrier is broken or not
System.out.println("Is it broken? - " + CyclicBarrierAwaitExample2.newBarrier.isBroken());
total = 20 + 20;
try
{
CyclicBarrierAwaitExample2.newBarrier.await(2000, TimeUnit.MILLISECONDS);
System.out.println("Number of rooms waiting at the barrier "+
"here = " + CyclicBarrierAwaitExample2.newBarrier.getNumberWaiting());
}
catch (InterruptedException | BrokenBarrierException e)
{
e.printStackTrace();
}
catch (TimeoutException e)
{
e.printStackTrace();
}
}
}
public class CyclicBarrierAwaitExample2 implements Runnable
{
public static CyclicBarrier newBarrier = new CyclicBarrier(3);
public static void main(String[] args)
{
CyclicBarrierAwaitExample2 test = new CyclicBarrierAwaitExample2();
Thread t = new Thread(test);
t.start();
}
@Override
public void run()
{
System.out.println("Number of parties required to trip the barrier = "+
newBarrier.getParties());
System.out.println("Sum of product and sum = " + (Comput1.item +
Comput2.total));
Comput1 comp1 = new Comput1();
Comput2 comp2 = new Comput2();
Thread t = new Thread(comp1);
Thread t2 = new Thread(comp2);
t.start();
t2.start();
TimeUnit unit = TimeUnit.SECONDS;
try
{
CyclicBarrierAwaitExample2.newBarrier.await(1,unit);
}
catch (InterruptedException | BrokenBarrierException | TimeoutException e)
{
e.printStackTrace();
}
System.out.println("Sum of item and total = " + (Comput1.item +
Comput2.total));
newBarrier.reset();
System.out.println(" reset successful");
}
}

Explication

Pendant que l'autre thread traite une tâche, la valeur est résumée.

Sortie :

Exemple #3

Code :

import java.util.*;
import java.util.concurrent.*;
public class Async {
static List<Task> tasks = new ArrayList<>();
static ExecutorService executor = Executors.newScheduledThreadPool(3);
public static void main(String[] args) {
createTasks();
executeTasks();
}
private static void createTasks() {
for (int k= 0; k < 10; k++) {
tasks.add(new Task(k));
}
}
private static void executeTasks() {
for (Task task : tasks) {
executor.submit(task);
}
}
static class Task extends Thread {
int n;
public void run() {
try {
Thread.sleep(new Random (). nextInt (1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
printNum();
}
private void printNum() {
System.out.print(n + " ");
}
public Task(int n) {
this.n = n;
}
}
}

Explication

Le code ci-dessus lance une tâche en attribuant une valeur de thread, c'est-à-dire un thread de travail. Ici, nous arrêtons la tâche synchrone dans la fonction print numb(). Par conséquent, le résultat ressemble à ceci :

Sortie :

Exemple n°4 – Temps secondes

Async.html

<html>
<meta charset="utf-8"/>
<body> Understanding JavaScript Program Execution</br>
<script type="text/javascript">
function tensec()
{
return new Promise((resolve,reject)=>{ setTimeout(() => {
console.log('EDUCBA PAge -I take 20 second');
resolve();
}, 10000);
});
}
async function run()
{
console.log('EDUCBA PAge : Page executed immediately');
await tensec();
console.log('EDUCBA PAge : Next process');
}
run();
</script>
</body>
</html>

Explication

Le code ci-dessus exécute ses promesses et affiche leur intervalle de temps d'attente à l'aide de async-await. Par exemple, le script ci-dessus attend 20 secondes pour terminer la tâche.

Sortie :

Conclusion

Pour finir, écrire du code asynchrone est un peu plus difficile, et surtout, les promesses sont le moyen général de définir le flux d'exécution retardée. Dans cet article, nous avons appris à écrire du code asynchrone qui semble synchrone. L'utilisation de l'async a été plus importante dans le code complexe. Le développeur JavaScript doit bien comprendre ce concept.

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!