Java 异步等待

Java 异步等待被定义为执行 I/O 绑定操作，不需要任何应用程序响应能力。这些函数通常用于文件和网络操作，因为它们需要在操作完成时执行回调；另外这个函数总是返回一个值。借助 awake 关键字，在常规控制流语句内使用异步调用，并且它是非阻塞代码。在本主题中，我们将学习 Java 异步等待。

广告 该类别中的热门课程 JAVA 掌握 - 专业化 | 78 课程系列 | 15 次模拟测试

开始您的免费软件开发课程

网络开发、编程语言、软件测试及其他

语法

async/await 的一般签名为

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

等待就像

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

Java 中的 async-await 函数是如何工作的？

异步等待函数有助于编写同步代码，同时在代码后面执行异步任务。我们需要有 async 关键字。接下来是等待的部分，它表示正常运行异步代码并继续执行下一行代码。当在异步函数中使用时，新的运算符“Await”会自动等待承诺来解析正在运行的进程。但是，在任何其他情况下使用时，它都会导致语法错误。

如果函数在错误处理中抛出错误，异步函数的 Promise 将被拒绝。如果相应的函数恰好返回一个值，则承诺将被解决。该非阻塞代码在单独的线程上运行，并通知主线程任务完成或失败。 Try-catch 在函数中使用来同步处理错误。让我们以

开头的示例

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

上面的代码表示函数 hello() 是异步的，通过返回一个数字来解决它，并通过检查数字来抛出错误。

接下来，使用await和return一起暂停一个进程

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

使用此函数更好的有前途的链接如下

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

所以这里await关键字指示函数get()在捕获错误之前完成。

有了这个 Completable future，它会返回一个 future 对象。这个 Completable future 是对异步计算的引用并实现了 future。

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

Java 异步等待示例

所以在本节中，我们将了解 async 和 wait 的优点是如何在这里工作的。

示例#1

代码：

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

说明

上面的代码使用了future，Java 7版本的API，等待十秒显示10。

输出：

示例#2

代码：

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

说明

当另一个线程正在处理任务时，该值会被求和。

输出：

示例 #3

代码：

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

说明

上面的代码通过分配一个线程值来启动一个任务，即工作线程。这里我们在 print numb() 函数中停止同步任务。因此，输出如下所示：

输出：

示例 #4 – 时间秒

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>

说明

上面的代码执行它的promise并在async-await的帮助下显示它们的等待时间间隔。例如，上面的脚本等待 20 秒才能完成任务。

输出：

结论

总而言之，编写异步代码有点困难，最重要的是，Promise 是定义延迟执行流程的通用方法。在本文中，我们学习了如何编写看起来像同步的异步代码。在复杂的代码中使用异步更为重要。 JavaScript 开发人员必须深入了解这个概念。

以上是Java 异步等待的详细内容。更多信息请关注PHP中文网其他相关文章！