Java async menanti

Java Asynchronous wait ditakrifkan sebagai melaksanakan operasi terikat I/O dan tidak memerlukan sebarang tindak balas aplikasi. Fungsi ini biasanya digunakan dalam operasi fail dan rangkaian kerana ia memerlukan panggilan balik dilaksanakan apabila operasi selesai; juga bahawa fungsi ini sentiasa mengembalikan nilai. Dengan bantuan kata kunci terjaga, panggilan tak segerak digunakan dalam penyataan aliran kawalan biasa dan ia merupakan kod tidak menyekat. Dalam topik ini, kita akan belajar tentang Java async menanti.

IKLAN Kursus Popular dalam kategori ini JAVA MASTERY - Pengkhususan | 78 Siri Kursus | 15 Ujian Olok-olok

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Sintaks

Tandatangan am async / menunggu diberikan sebagai

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

Penantian berterusan seperti

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

Bagaimanakah fungsi async-await berfungsi dalam Java?

Fungsi async menunggu membantu menulis kod segerak semasa melaksanakan tugas async di belakang kod. Dan kita perlu mempunyai kata kunci async. Dan seterusnya ialah bahagian yang ditunggu-tunggu yang mengatakan untuk menjalankan kod tak segerak seperti biasa dan meneruskan ke baris kod seterusnya. Operator baharu "Tunggu" secara automatik menunggu janji untuk menyelesaikan proses berjalan apabila digunakan dalam fungsi async. Walau bagaimanapun, ia menyebabkan ralat sintaks apabila digunakan dalam mana-mana kes lain.

Jika fungsi menimbulkan ralat dalam pengendalian ralat, janji fungsi async akan ditolak. Jika fungsi masing-masing berlaku untuk mengembalikan nilai, janji akan diselesaikan. Kod tidak menyekat ini berjalan pada utas yang berasingan dan memberitahu utas utama tentang penyiapan atau kegagalan tugasan. Try-catch digunakan dalam fungsi untuk mengendalikan ralat secara serentak. Mari kita ambil sampel bermula seperti

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

Kod di atas mengatakan bahawa fungsi hello() tidak segerak, menyelesaikannya dengan mengembalikan nombor dan melemparkan ralat dengan menyemak nombor.

Seterusnya, gunakan await dan return bersama-sama untuk menangguhkan proses

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

Perantaian menjanjikan yang lebih baik dengan fungsi ini diberikan sebagai

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

Jadi di sini tunggu kata kunci mengarahkan fungsi get () untuk dilengkapkan sebelum menangkap ralat.

Dengan masa depan Completable ini, ia mengembalikan objek masa hadapan. Masa depan Boleh Lengkap ini merujuk kepada pengiraan tak segerak dan melaksanakan masa hadapan.

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

Contoh Java async menanti

Jadi dalam bahagian ini, kita akan melihat cara titik async dan menunggu yang lebih baik berfungsi di sini.

Contoh #1

Kod:

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

Penjelasan

Kod di atas menggunakan masa hadapan, API versi Java 7 dan menunggu sepuluh saat untuk memaparkan 10.

Output:

Contoh #2

Kod:

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

Penjelasan

Semasa urutan lain sedang memproses tugasan, nilainya disimpulkan.

Output:

Contoh #3

Kod:

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

Penjelasan

Kod di atas memulakan tugas dengan memberikan nilai utas, iaitu, utas pekerja. Di sini kita menghentikan tugas segerak dalam fungsi print numb(). Oleh itu, output kelihatan seperti ini:

Output:

Contoh #4 – Masa saat

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>

Penjelasan

Kod di atas melaksanakan janjinya dan menunjukkan selang masa menunggunya dengan bantuan async-await. Contohnya, skrip di atas menunggu selama 20 saat untuk menyelesaikan tugasan.

Output:

Kesimpulan

Menjelang penghujung, menulis kod tak segerak adalah sedikit lebih sukar, dan yang paling penting, janji ialah cara umum untuk menentukan aliran pelaksanaan tertangguh. Dalam artikel ini, kami mempelajari cara menulis kod tak segerak yang kelihatan seperti segerak. Menggunakan async telah menjadi lebih penting dalam kod kompleks. Pembangun JavaScript mesti memahami banyak tentang konsep ini.

Atas ialah kandungan terperinci Java async menanti. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!