Pengantar Pemrograman Asinkron di Rust

Model pemrograman sinkron tradisional sering menyebabkan kemacetan kinerja. Ini karena program menunggu operasi yang lambat selesai sebelum melanjutkan ke tugas berikutnya. Hal ini sering mengakibatkan penggunaan sumber daya yang buruk dan pengalaman pengguna yang lamban.

Pemrograman asinkron memungkinkan Anda menulis kode non-pemblokiran yang menggunakan sumber daya sistem secara efektif. Dengan memanfaatkan pemrograman asinkron, Anda dapat merancang aplikasi yang menjalankan banyak tugas. Pemrograman asinkron berguna untuk menangani beberapa permintaan jaringan atau memproses data dalam jumlah besar tanpa menghalangi aliran eksekusi.

Pemrograman Asinkron di Rust

Model pemrograman asinkron Rust memungkinkan Anda melakukannya tulis kode Rust yang efisien yang berjalan secara bersamaan tanpa menghalangi aliran eksekusi. Pemrograman asinkron bermanfaat saat menangani operasi I/O, permintaan jaringan, dan tugas yang melibatkan menunggu sumber daya eksternal.

Anda dapat mengimplementasikan pemrograman asinkron di aplikasi Rust dengan beberapa cara. Ini termasuk fitur bahasa, perpustakaan, dan runtime Tokio.

Juga, Model kepemilikan Rust dan primitif konkurensi seperti saluran dan kunci memungkinkan pemrograman bersamaan yang aman dan efisien. Anda dapat memanfaatkan fitur ini dengan pemrograman asinkron untuk membangun sistem bersamaan yang dapat diskalakan dengan baik dan menggunakan banyak inti CPU.

Konsep Pemrograman Asinkron Rust

Futures memberikan dasar untuk pemrograman asinkron di Rust. Masa depan mewakili komputasi asinkron yang belum sepenuhnya dieksekusi.

Masa depan malas (mereka hanya dieksekusi saat pemungutan suara). Ketika Anda menelepon masa depan pemilihan() Metode ini memeriksa apakah masa depan telah selesai atau perlu pekerjaan tambahan. Jika masa depan belum siap, ia kembali Polling:: Tertunda, menunjukkan bahwa tugas harus dijadwalkan untuk eksekusi nanti. Jika masa depan sudah siap, ia kembali Polling:: Siap dengan nilai yang dihasilkan.

Toolchain standar Rust mencakup primitif I/O asinkron, versi I/O file asinkron, jaringan, dan pengatur waktu. Primitif ini memungkinkan Anda melakukan operasi I/O secara asinkron. Ini membantu menghindari pemblokiran eksekusi program sambil menunggu tugas I/O selesai.

Sintaks async/menunggu memungkinkan Anda untuk menulis kode asinkron yang mirip dengan kode sinkron. Ini membuat kode Anda intuitif dan mudah dipelihara.

Pendekatan Rust terhadap pemrograman asinkron menekankan keamanan dan kinerja. Aturan kepemilikan dan peminjaman memastikan keamanan memori dan mencegah masalah konkurensi umum. Sintaks async/menunggu dan masa depan menyediakan cara intuitif untuk mengekspresikan alur kerja asinkron. Anda dapat menggunakan runtime pihak ketiga untuk mengelola tugas untuk eksekusi yang efisien.

Anda dapat mengombinasikan fitur bahasa, pustaka, dan runtime ini untuk menulis kode berperforma tinggi. Ini memberikan kerangka kerja yang kuat dan ergonomis untuk membangun sistem asinkron. Hal ini membuat Rust menjadi pilihan populer untuk proyek yang memerlukan penanganan tugas yang terikat I/O secara efisien dan konkurensi tinggi.

Rust versi 1.39 dan rilis yang lebih baru tidak mendukung operasi asinkron di pustaka standar Rust. Anda memerlukan peti pihak ketiga untuk menggunakan asinkron/menunggu sintaks untuk menangani operasi asinkron di Rust. Anda dapat menggunakan paket pihak ketiga seperti Tokio atau async-std untuk bekerja dengan sintaks async/menunggu.

Pemrograman Asinkron Dengan Tokio

Tokio adalah runtime asinkron yang tangguh untuk Rust. Ini menyediakan fungsionalitas untuk membangun aplikasi yang berperforma tinggi dan dapat diskalakan. Anda dapat memanfaatkan kekuatan pemrograman asinkron dengan Tokio. Ini juga menyediakan fitur untuk ekstensibilitas.

Inti dari Tokio adalah model eksekusi dan penjadwalan tugas asinkronnya. Tokio memungkinkan Anda menulis kode asinkron dengan sintaks async/menunggu. Hal ini memungkinkan pemanfaatan sumber daya sistem yang efisien dan pelaksanaan tugas bersamaan. Loop acara Tokio secara efisien mengelola penjadwalan tugas. Ini memastikan pemanfaatan inti CPU yang optimal dan meminimalkan overhead pengalihan konteks.

Kombinator Tokio memudahkan koordinasi dan komposisi Tugas. Tokio menyediakan alat koordinasi tugas dan komposisi yang andal. Anda dapat menunggu beberapa tugas selesai dengan bergabung, pilih tugas pertama yang diselesaikan dengan pilih dan balapan tugas satu sama lain dengan balapan.

Tambahkan tokio peti ke Anda Kargo.toml bagian dependensi file.

[dependencies]
tokio = { version = "1.9", features = ["full"] }

Inilah cara Anda dapat menggunakan sintaks async/menunggu dalam program Rust Anda dengan Tokio:

use tokio:: time:: sleep;
use std:: time:: Duration;
asyncfnhello_world() {
println!("Hello, ");
 sleep(Duration:: from_secs(1)).await;
println!("World!");
}
#[tokio:: main]
asyncfnmain() {
 hello_world().await;
}

Itu Halo Dunia fungsi asinkron, sehingga dapat menggunakan menunggu kata kunci untuk menjeda eksekusinya sampai masa depan diselesaikan. Itu Halo Dunia cetakan fungsi "Halo, " ke konsol. Itu Durasi:: from_secs (1) panggilan fungsi menangguhkan eksekusi fungsi untuk sesaat. Itu menunggu kata kunci menunggu masa depan tidur selesai. Akhirnya, Halo Dunia cetakan fungsi "Dunia!" ke konsol.

Itu utama fungsi adalah fungsi asinkron dengan #[tokio:: utama] atribut. Ini menunjuk fungsi utama sebagai titik masuk untuk runtime Tokio. Itu hello_world().menunggu mengeksekusi fungsi hello_world secara asinkron.

Menunda Tugas Dengan Tokio

Tugas umum dalam pemrograman asinkron menggunakan penundaan atau penjadwalan tugas untuk dijalankan dalam rentang waktu tertentu. Runtime tokio menyediakan mekanisme untuk menggunakan pengatur waktu asinkron dan penundaan melalui tokio:: waktu modul.

Inilah cara Anda dapat menunda operasi dengan runtime Tokio:

use std:: time:: Duration;
use tokio:: time:: sleep;
asyncfndelayed_operation() {
println!("Performing delayed operation...");
 sleep(Duration:: from_secs(2)).await;
println!("Delayed operation completed.");
}
#[tokio:: main]
asyncfnmain() {
println!("Starting...");
 delayed_operation().await;
println!("Finished.");
}

Itu operasi_tertunda fungsi memperkenalkan penundaan dua detik dengan tidur metode. Itu operasi_tertunda fungsi asinkron, sehingga dapat menggunakan await untuk menjeda eksekusinya hingga penundaan selesai.

Penanganan Kesalahan dalam Program Asinkron

Penanganan kesalahan dalam kode Rust asinkron melibatkan penggunaan Hasil jenis dan menangani kesalahan Rust dengan ? operator.

use tokio:: fs:: File;
use tokio:: io;
use tokio:: io::{AsyncReadExt};
asyncfnread_file_contents() -> io::Result<String> {
letmut file = File:: open("file.txt").await?;
letmut contents = String::new();
 file.read_to_string(&mut contents).await?;
Ok(contents)
}
asyncfnprocess_file() -> io::Result {
let contents = read_file_contents().await?;
// Process the file contents
Ok(())
}
#[tokio:: main]
asyncfnmain() {
match process_file().await {
Ok(()) => println!("File processed successfully."),
Err(err) => eprintln!("Error processing file: {}", err),
 }
}

Itu read_file_contents fungsi mengembalikan an io:: Hasil yang mewakili kemungkinan kesalahan I/O. Dengan menggunakan ? operator setelah setiap operasi asinkron, runtime Tokio akan menyebarkan kesalahan ke tumpukan panggilan.

Itu utama fungsi menangani hasil dengan a cocok pernyataan yang mencetak teks berdasarkan hasil operasi.

Reqwest Menggunakan Pemrograman Asinkron untuk Operasi HTTP

Banyak peti populer, termasuk Reqwest, menggunakan Tokio untuk menyediakan operasi HTTP asinkron.

Anda dapat menggunakan Tokio dengan Reqwest untuk membuat beberapa permintaan HTTP tanpa memblokir tugas lainnya. Tokio dapat membantu Anda menangani ribuan koneksi bersamaan dan mengelola sumber daya secara efisien.