Java async wartet

Java Asynchronous Wait ist als Ausführung von I/O-gebundenen Vorgängen definiert und erfordert keine Reaktionsfähigkeit der Anwendung. Diese Funktionen werden normalerweise in Datei- und Netzwerkoperationen verwendet, da sie Rückrufe erfordern, die nach Abschluss der Operation ausgeführt werden. auch, dass diese Funktion immer einen Wert zurückgibt. Mit Hilfe des Schlüsselworts wake werden asynchrone Aufrufe innerhalb regulärer Kontrollflussanweisungen verwendet und es handelt sich um einen nicht blockierenden Code. In diesem Thema erfahren Sie mehr über Java Async Wait.

WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 Probetests

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax

Die allgemeine Signatur von async/await lautet:

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

Das Warten geht weiter wie

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

Wie funktioniert die Async-Await-Funktion in Java?

Die Async-Waits-Funktion hilft beim Schreiben von synchronem Code, während asynchrone Aufgaben hinter dem Code ausgeführt werden. Und wir brauchen das Schlüsselwort async. Und als nächstes folgt der erwartete Teil, der besagt, dass der asynchrone Code normal ausgeführt und mit der nächsten Codezeile fortgefahren werden soll. Der neue Operator „Await“ wartet automatisch auf ein Versprechen, den laufenden Prozess aufzulösen, wenn er innerhalb einer asynchronen Funktion verwendet wird. Bei Verwendung in anderen Fällen führt es jedoch zu Syntaxfehlern.

Wenn die Funktion einen Fehler bei der Fehlerbehandlung auslöst, wird das Versprechen der asynchronen Funktion abgelehnt. Wenn die entsprechende Funktion zufällig einen Wert zurückgibt, wird das Versprechen gelöst. Dieser nicht blockierende Code wird in einem separaten Thread ausgeführt und benachrichtigt den Hauptthread über den Abschluss oder das Scheitern einer Aufgabe. Try-Catch wird in einer Funktion verwendet, um die Fehler synchron zu behandeln. Nehmen wir ein Beispiel, beginnend mit

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';
}

Der obige Code besagt, dass die Funktion hello() asynchron ist, sie durch die Rückgabe einer Zahl auflöst und durch Überprüfen der Zahl einen Fehler auslöst.

Als nächstes verwenden Sie „await“ und „return“ zusammen, um einen Prozess anzuhalten

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

Eine erfolgsversprechendere Verkettung mit dieser Funktion ist gegeben als

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);
}
}

Das Schlüsselwort „wait“ weist hier also an, dass die Funktion get() abgeschlossen wird, bevor ein Fehler erkannt wird.

Mit diesem Completable Future wird ein Future-Objekt zurückgegeben. Diese Completable Future ist ein Verweis auf asynchrone Berechnungen und implementiert die Zukunft.

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);
}

Beispiele für Java-Async-Await

In diesem Abschnitt werden wir also sehen, wie die Feinheiten von Async und Wait hier funktionieren.

Beispiel #1

Code:

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

Erklärung

Der obige Code verwendet die Zukunft, die Java 7-Versions-API, und wartet zehn Sekunden, um 10 anzuzeigen.

Ausgabe:

Beispiel #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");
}
}

Erklärung

Während der andere Thread eine Aufgabe bearbeitet, wird der Wert summiert.

Ausgabe:

Beispiel #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;
}
}
}

Erklärung

Der obige Code initiiert eine Aufgabe durch Zuweisen eines Thread-Werts, d. h. eines Arbeitsthreads. Hier stoppen wir die synchrone Aufgabe in der Funktion print numb(). Daher sieht die Ausgabe so aus:

Ausgabe:

Beispiel #4 – Zeitsekunden

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>

Erklärung

Der obige Code führt seine Versprechen aus und zeigt ihr Wartezeitintervall mit Hilfe von async-await an. Das obige Skript wartet beispielsweise 20 Sekunden, um die Aufgabe abzuschließen.

Ausgabe:

Fazit

Abschließend möchte ich sagen, dass das Schreiben von asynchronem Code etwas schwieriger ist, und was am wichtigsten ist: Versprechen sind die allgemeine Möglichkeit, den Ablauf der verzögerten Ausführung zu definieren. In diesem Artikel haben wir gelernt, wie man asynchronen Code schreibt, der wie synchron aussieht. Die Verwendung von Async war bei komplexem Code wichtiger. Der JavaScript-Entwickler muss viel über dieses Konzept verstehen.

Das obige ist der detaillierte Inhalt vonJava async wartet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!