Menyerahkan Kontrol ke Runtime
Ingat dari bagian “Program Async Pertama Kita” bahwa di setiap await point, Rust memberi runtime kesempatan untuk menjeda task dan beralih ke task lain jika future yang sedang di-await belum siap. Kebalikannya juga benar: Rust hanya menjeda blok async dan menyerahkan kontrol kembali ke runtime di sebuah await point. Semua yang ada di antara await point bersifat sinkron.
Itu berarti jika kamu melakukan banyak pekerjaan di dalam blok async tanpa await point, future itu akan menghalangi future lain untuk maju. Kamu kadang akan mendengar hal ini disebut sebagai satu future starving future lainnya. Dalam beberapa kasus, ini mungkin bukan masalah besar. Namun, jika kamu melakukan semacam inisialisasi yang mahal atau pekerjaan yang berjalan lama, atau jika kamu punya future yang akan terus melakukan suatu task tertentu tanpa henti, kamu perlu memikirkan kapan dan di mana menyerahkan kontrol kembali ke runtime.
Mari kita simulasikan operasi yang berjalan lama untuk menggambarkan masalah starvation, lalu kita bahas cara mengatasinya. Listing 17-14 memperkenalkan fungsi slow.
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
// We will call `slow` here later
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
thread::sleep untuk menyimulasikan operasi yang lambatKode ini menggunakan std::thread::sleep, bukan trpl::sleep, sehingga memanggil slow akan memblokir thread saat ini selama sejumlah milidetik. Kita bisa memakai slow sebagai pengganti operasi di dunia nyata yang berjalan lama sekaligus memblokir.
Di Listing 17-15, kita memakai slow untuk meniru pekerjaan yang terikat CPU semacam ini pada sepasang future.
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
let a = async {
println!("'a' started.");
slow("a", 30);
slow("a", 10);
slow("a", 20);
trpl::sleep(Duration::from_millis(50)).await;
println!("'a' finished.");
};
let b = async {
println!("'b' started.");
slow("b", 75);
slow("b", 10);
slow("b", 15);
slow("b", 350);
trpl::sleep(Duration::from_millis(50)).await;
println!("'b' finished.");
};
trpl::select(a, b).await;
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
slow untuk menyimulasikan operasi yang lambatSetiap future menyerahkan kontrol kembali ke runtime hanya setelah menjalankan sejumlah operasi lambat. Jika kamu menjalankan kode ini, kamu akan melihat output ini:
'a' started.
'a' ran for 30ms
'a' ran for 10ms
'a' ran for 20ms
'b' started.
'b' ran for 75ms
'b' ran for 10ms
'b' ran for 15ms
'b' ran for 350ms
'a' finished.
Sama seperti Listing 17-5, tempat kita memakai trpl::select untuk membalapkan future-future yang mengambil dua URL, select tetap selesai begitu a selesai. Namun, tidak ada selang-seling di antara pemanggilan slow pada kedua future itu. Future a melakukan seluruh pekerjaannya sampai pemanggilan trpl::sleep di-await, lalu future b melakukan seluruh pekerjaannya sampai pemanggilan trpl::sleep-nya sendiri di-await, dan akhirnya future a selesai. Agar kedua future bisa maju di antara tugas-tugas lambatnya, kita butuh await point supaya bisa menyerahkan kontrol kembali ke runtime. Artinya, kita butuh sesuatu yang bisa kita await!
Kita sudah bisa melihat semacam serah-terima ini terjadi di Listing 17-15: jika kita menghapus trpl::sleep di akhir future a, future itu akan selesai tanpa future b berjalan sama sekali. Mari kita coba memakai fungsi trpl::sleep sebagai titik awal untuk membiarkan operasi bergantian maju, seperti yang ditunjukkan Listing 17-16.
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
let one_ms = Duration::from_millis(1);
let a = async {
println!("'a' started.");
slow("a", 30);
trpl::sleep(one_ms).await;
slow("a", 10);
trpl::sleep(one_ms).await;
slow("a", 20);
trpl::sleep(one_ms).await;
println!("'a' finished.");
};
let b = async {
println!("'b' started.");
slow("b", 75);
trpl::sleep(one_ms).await;
slow("b", 10);
trpl::sleep(one_ms).await;
slow("b", 15);
trpl::sleep(one_ms).await;
slow("b", 350);
trpl::sleep(one_ms).await;
println!("'b' finished.");
};
trpl::select(a, b).await;
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
trpl::sleep untuk membiarkan operasi bergantian majuKita sudah menambahkan pemanggilan trpl::sleep dengan await point di antara setiap pemanggilan slow. Sekarang pekerjaan kedua future berselang-seling:
'a' started.
'a' ran for 30ms
'b' started.
'b' ran for 75ms
'a' ran for 10ms
'b' ran for 10ms
'a' ran for 20ms
'b' ran for 15ms
'a' finished.
Future a masih berjalan sebentar sebelum menyerahkan kontrol ke b, karena ia memanggil slow sebelum sempat memanggil trpl::sleep, tetapi setelah itu kedua future bergantian setiap kali salah satunya mencapai await point. Dalam kasus ini, kita melakukannya setelah setiap pemanggilan slow, tetapi kita bisa memecah pekerjaan itu dengan cara apa pun yang paling masuk akal bagi kita.
Meski begitu, kita sebenarnya tidak ingin tidur di sini: kita ingin maju secepat mungkin. Kita hanya perlu menyerahkan kontrol kembali ke runtime. Kita bisa melakukannya secara langsung dengan fungsi trpl::yield_now. Di Listing 17-17, kita mengganti semua pemanggilan trpl::sleep itu dengan trpl::yield_now.
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
let a = async {
println!("'a' started.");
slow("a", 30);
trpl::yield_now().await;
slow("a", 10);
trpl::yield_now().await;
slow("a", 20);
trpl::yield_now().await;
println!("'a' finished.");
};
let b = async {
println!("'b' started.");
slow("b", 75);
trpl::yield_now().await;
slow("b", 10);
trpl::yield_now().await;
slow("b", 15);
trpl::yield_now().await;
slow("b", 350);
trpl::yield_now().await;
println!("'b' finished.");
};
trpl::select(a, b).await;
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
yield_now untuk membiarkan operasi bergantian majuKode ini lebih jelas soal niat sebenarnya dan bisa jauh lebih cepat daripada memakai sleep, karena timer seperti yang dipakai sleep sering punya batas seberapa halus granularitasnya. Versi sleep yang kita pakai, misalnya, selalu tidur setidaknya satu milidetik, bahkan jika kita memberinya Duration satu nanodetik. Sekali lagi, komputer modern itu cepat: mereka bisa melakukan banyak hal dalam satu milidetik!
Ini berarti async bisa berguna bahkan untuk task yang terikat komputasi, tergantung pada apa lagi yang dilakukan programmu, karena async menyediakan alat yang berguna untuk menyusun hubungan antarbagian program (meski dengan biaya overhead mesin state async). Ini adalah bentuk cooperative multitasking, tempat setiap future punya kuasa menentukan kapan ia menyerahkan kontrol lewat await point. Karena itu, setiap future juga punya tanggung jawab untuk tidak memblokir terlalu lama. Pada beberapa sistem operasi embedded berbasis Rust, ini adalah satu-satunya jenis multitasking!
Dalam kode dunia nyata, tentu saja kamu tidak akan biasa bergantian antara pemanggilan fungsi dan await point di setiap baris. Meski menyerahkan kontrol dengan cara ini tergolong murah, hal itu tidaklah gratis. Dalam banyak kasus, mencoba memecah task yang terikat komputasi justru bisa membuatnya jauh lebih lambat, jadi kadang lebih baik bagi performa keseluruhan membiarkan suatu operasi memblokir sebentar. Selalu ukur untuk melihat di mana sebenarnya bottleneck performa kodemu. Meski begitu, dinamika yang mendasari ini penting untuk diingat jika kamu memang melihat banyak pekerjaan terjadi secara serial, padahal kamu mengharapkannya terjadi secara bersamaan!
Membangun Abstraksi Async Kita Sendiri
Kita juga bisa menggabungkan future-future untuk menciptakan pola baru. Misalnya, kita bisa membangun fungsi timeout dari komponen dasar async yang sudah kita punya. Setelah selesai, hasilnya akan menjadi komponen dasar lain yang bisa kita pakai untuk membuat abstraksi async lagi.
Listing 17-18 menunjukkan bagaimana kita mengharapkan timeout ini bekerja dengan future yang lambat.
extern crate trpl; // required for mdbook test
use std::time::Duration;
fn main() {
trpl::block_on(async {
let slow = async {
trpl::sleep(Duration::from_secs(5)).await;
"Finally finished"
};
match timeout(slow, Duration::from_secs(2)).await {
Ok(message) => println!("Succeeded with '{message}'"),
Err(duration) => {
println!("Failed after {} seconds", duration.as_secs())
}
}
});
}
timeout bayangan kita untuk menjalankan operasi lambat dengan batas waktuMari kita terapkan ini! Untuk mulai, mari kita pikirkan API untuk timeout:
- Fungsi ini harus berupa fungsi async agar bisa kita await.
- Parameter pertamanya seharusnya future yang akan dijalankan. Kita bisa menjadikannya generic agar bisa bekerja dengan future apa pun.
- Parameter keduanya adalah waktu tunggu maksimum. Jika kita memakai
Duration, itu akan memudahkan kita meneruskannya ketrpl::sleep. - Fungsi ini harus mengembalikan
Result. Jika future selesai dengan sukses,Result-nya akan berupaOkdengan nilai yang dihasilkan future. Jika waktu habis lebih dulu,Result-nya akan berupaErrdengan durasi yang sudah ditunggu timeout.
Listing 17-19 menunjukkan deklarasi ini.
extern crate trpl; // required for mdbook test
use std::time::Duration;
fn main() {
trpl::block_on(async {
let slow = async {
trpl::sleep(Duration::from_secs(5)).await;
"Finally finished"
};
match timeout(slow, Duration::from_secs(2)).await {
Ok(message) => println!("Succeeded with '{message}'"),
Err(duration) => {
println!("Failed after {} seconds", duration.as_secs())
}
}
});
}
async fn timeout<F: Future>(
future_to_try: F,
max_time: Duration,
) -> Result<F::Output, Duration> {
// Here is where our implementation will go!
}
timeoutItu memenuhi tujuan kita untuk tipe-tipe tersebut. Sekarang mari kita pikirkan perilaku yang kita butuhkan: kita ingin membalapkan future yang diteruskan dengan durasi itu. Kita bisa memakai trpl::sleep untuk membuat timer dari durasi tersebut, lalu memakai trpl::select untuk menjalankan timer itu bersama future yang diteruskan pemanggil.
Di Listing 17-20, kita menerapkan timeout dengan mencocokkan hasil dari await trpl::select.
extern crate trpl; // required for mdbook test
use std::time::Duration;
use trpl::Either;
// --snip--
fn main() {
trpl::block_on(async {
let slow = async {
trpl::sleep(Duration::from_secs(5)).await;
"Finally finished"
};
match timeout(slow, Duration::from_secs(2)).await {
Ok(message) => println!("Succeeded with '{message}'"),
Err(duration) => {
println!("Failed after {} seconds", duration.as_secs())
}
}
});
}
async fn timeout<F: Future>(
future_to_try: F,
max_time: Duration,
) -> Result<F::Output, Duration> {
match trpl::select(future_to_try, trpl::sleep(max_time)).await {
Either::Left(output) => Ok(output),
Either::Right(_) => Err(max_time),
}
}
timeout dengan select dan sleepImplementasi trpl::select tidak adil: ia selalu melakukan poll argumen sesuai urutan saat argumen itu diteruskan (implementasi select lain akan memilih secara acak argumen mana yang di-poll lebih dulu). Karena itu, kita meneruskan future_to_try ke select lebih dulu agar ia punya kesempatan selesai bahkan jika max_time sangat singkat. Jika future_to_try selesai lebih dulu, select akan mengembalikan Left dengan hasil dari future_to_try. Jika timer selesai lebih dulu, select akan mengembalikan Right dengan hasil timer berupa ().
Jika future_to_try berhasil dan kita mendapat Left(output), kita mengembalikan Ok(output). Jika sebaliknya timer sleep habis dan kita mendapat Right(()), kita mengabaikan () dengan _ dan mengembalikan Err(max_time) sebagai gantinya.
Dengan begitu, kita punya timeout yang berfungsi, dibangun dari dua helper async lainnya. Jika kita menjalankan kode kita, ia akan mencetak pesan kegagalan setelah timeout:
Failed after 2 seconds
Karena future bisa digabung dengan future lain, kamu bisa membangun alat yang sangat kuat dari komponen dasar async yang lebih kecil. Misalnya, kamu bisa memakai pendekatan yang sama untuk menggabungkan timeout dengan retry, lalu memakai hasilnya untuk operasi seperti panggilan jaringan (seperti yang ada di Listing 17-5).
Dalam praktiknya, kamu biasanya akan bekerja langsung dengan async dan await, lalu secara sekunder dengan fungsi seperti select dan macro seperti macro join! untuk mengontrol cara future paling luar dijalankan.
Kita sudah melihat sejumlah cara untuk bekerja dengan banyak future secara bersamaan. Selanjutnya, kita akan melihat bagaimana kita bisa bekerja dengan banyak future secara berurutan dari waktu ke waktu memakai streams.