Ievads asinhronajā programmēšanā rūsā

Tradicionālie sinhronās programmēšanas modeļi bieži rada veiktspējas vājās vietas. Tas ir tāpēc, ka programma gaida, līdz tiks pabeigtas lēnas darbības, pirms pāriet uz nākamo uzdevumu. Tas bieži izraisa sliktu resursu izmantošanu un lēnu lietotāja pieredzi.

Asinhronā programmēšana ļauj rakstīt nebloķējošu kodu, kas efektīvi izmanto sistēmas resursus. Izmantojot asinhrono programmēšanu, varat izveidot programmas, kas veic vairākus uzdevumus. Asinhronā programmēšana ir ērta, lai apstrādātu vairākus tīkla pieprasījumus vai apstrādātu lielu datu apjomu, nebloķējot izpildes plūsmu.

Asinhronā programmēšana rūsā

Rust asinhronās programmēšanas modelis ļauj jums rakstīt efektīvu Rust kodu, kas darbojas vienlaikus nebloķējot izpildes plūsmu. Asinhronā programmēšana ir izdevīga, veicot I/O operācijas, tīkla pieprasījumus un uzdevumus, kas saistīti ar ārējo resursu gaidīšanu.

Jūs varat ieviest asinhrono programmēšanu savās Rust lietotnēs vairākos veidos. Tie ietver valodas funkcijas, bibliotēkas un Tokio izpildlaiku.

Tāpat Rust īpašumtiesību modelis un vienlaicīguma primitīvi, piemēram, kanāli un slēdzenes, nodrošina drošu un efektīvu vienlaicīgu programmēšanu. Varat izmantot šīs funkcijas ar asinhrono programmēšanu, lai izveidotu vienlaicīgas sistēmas, kas labi mērogojas un izmanto vairākus CPU kodolus.

Rustas asinhronās programmēšanas koncepcijas

Futures nodrošina pamatu asinhronai programmēšanai Rust. Nākotne ir asinhrons aprēķins, kas nav pilnībā izpildīts.

Nākotnes līgumi ir slinki (tie tiek izpildīti tikai balsošanas laikā). Kad jūs saucat par nākotni aptauja () metodi, tā pārbauda, ​​vai nākotne ir pabeigta vai ir nepieciešams papildu darbs. Ja nākotne nav gatava, tā atgriežas Aptauja:: Gaida, norādot, ka uzdevums ir jāieplāno vēlākai izpildei. Ja nākotne ir gatava, tā atgriežas Aptauja:: Gatavs ar iegūto vērtību.

Rust standarta rīku ķēdē ir iekļauti asinhronie I/O primitīvi, faila I/O asinhronā versija, tīkls un taimeri. Šie primitīvi ļauj veikt I/O darbības asinhroni. Tas palīdz izvairīties no programmas izpildes bloķēšanas, gaidot I/O uzdevumu pabeigšanu.

Asinhronā/gaidīšanas sintakse ļauj rakstīt asinhronu kodu, kas izskatās līdzīgs sinhronajam kodam. Tas padara jūsu kodu intuitīvu un viegli uzturējamu.

Rust pieeja asinhronajai programmēšanai uzsver drošību un veiktspēju. Īpašumtiesību un aizņemšanās noteikumi nodrošina atmiņas drošību un novērš bieži sastopamas vienlaicīgas problēmas. Asinhronās/gaidīšanas sintakse un nākotnes līgumi nodrošina intuitīvu veidu, kā izteikt asinhronās darbplūsmas. Varat izmantot trešās puses izpildlaiku, lai pārvaldītu uzdevumus efektīvai izpildei.

Varat apvienot šīs valodas funkcijas, bibliotēkas un izpildlaiku, lai rakstītu augstas veiktspējas kodu. Tas nodrošina jaudīgu un ergonomisku sistēmu asinhrono sistēmu veidošanai. Tas padara Rust par populāru izvēli projektiem, kuriem nepieciešama efektīva I/O uzdevumu apstrāde un augsta vienlaicība.

Rust versija 1.39 un jaunāki laidieni neatbalsta asinhronās darbības Rust standarta bibliotēkā. Lai izmantotu, jums būs nepieciešama trešās puses kaste asinhrons/gaidīt sintakse asinhrono darbību apstrādei programmā Rust. Varat izmantot trešās puses pakotnes, piemēram Tokio vai async-std lai strādātu ar asinhronās/gaidīšanas sintaksi.

Asinhronā programmēšana ar Tokiju

Tokio ir Rust spēcīgs asinhronais izpildlaiks. Tas nodrošina funkcionalitāti augstas veiktspējas un mērogojamu lietojumprogrammu izveidei. Jūs varat izmantot asinhronās programmēšanas spēku ar Tokiju. Tas nodrošina arī paplašināšanas iespējas.

Tokio pamatā ir tās asinhronais uzdevumu plānošanas un izpildes modelis. Tokio ļauj rakstīt asinhronu kodu ar asinhrono/gaidīšanas sintaksi. Tas nodrošina efektīvu sistēmas resursu izmantošanu un vienlaicīgu uzdevumu izpildi. Tokio notikumu cilpa efektīvi pārvalda uzdevumu plānošanu. Tas nodrošina optimālu CPU kodolu izmantošanu un samazina konteksta pārslēgšanu.

Tokios kombinatori atvieglo uzdevumu koordinēšanu un kompozīciju. Tokio nodrošina jaudīgus uzdevumu koordinēšanas un kompozīcijas rīkus. Varat gaidīt, līdz tiks izpildīti vairāki uzdevumi, pievienojoties, atlasīt pirmo izpildīto uzdevumu ar atlasi un sacensties savā starpā ar sacīkstēm.

Pievienojiet tokio kaste tev Krava.toml faila atkarību sadaļa.

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

Lūk, kā jūs varat izmantot asinhrono/gaidīšanas sintaksi savās Rust programmās ar 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;
}

The Sveika pasaule funkcija ir asinhrona, tāpēc tā var izmantot gaidīt atslēgvārdu, lai apturētu tā izpildi, līdz tiek atrisināta nākotne. The Sveika pasaule funkciju izdrukas "Sveiki, " uz konsoli. The Ilgums:: from_sec (1) funkcijas izsaukums aptur funkcijas izpildi uz sekundi. The gaidīt atslēgvārds gaida, līdz tiks pabeigta miega nākotne. Visbeidzot, Sveika pasaule funkciju izdrukas "Pasaule!" uz konsoli.

The galvenais funkcija ir asinhrona funkcija ar #[tokio:: galvenais] atribūts. Tas apzīmē galveno funkciju kā Tokio izpildlaika ieejas punktu. The hello_world().gaidiet asinhroni izpilda funkciju hello_world.

Uzdevumu aizkavēšana ar Tokiju

Izplatīts uzdevums asinhronajā programmēšanā ir aizkavēšanās vai uzdevumu plānošana, lai tie tiktu izpildīti noteiktā laika diapazonā. Tokio izpildlaiks nodrošina mehānismu asinhrono taimeru un aizkaves izmantošanai caur tokio:: laiks modulis.

Lūk, kā jūs varat aizkavēt operāciju ar Tokio izpildlaiku:

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

The aizkavēta_operācija funkcija ievieš divu sekunžu aizkavi ar Gulēt metodi. The aizkavēta_operācija funkcija ir asinhrona, tāpēc tā var izmantot gaidīšanu, lai apturētu tās izpildi, līdz aizkave ir pabeigta.

Kļūdu apstrāde asinhronajās programmās

Kļūdu apstrāde asinhronajā Rust kodā ietver izmantošanu Rezultāts veids un rūsas kļūdu apstrāde Ar ? operators.

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

The lasīt_failu_saturu funkcija atgriež an io:: Rezultāts kas norāda uz I/O kļūdas iespējamību. Izmantojot ? operators pēc katras asinhronās darbības, Tokio izpildlaiks izplatīs kļūdas uz augšu zvanu stekā.

The galvenais funkcija apstrādā rezultātu ar a atbilst paziņojums, kas izdrukā tekstu, pamatojoties uz operācijas iznākumu.

Reqwest izmanto asinhrono programmēšanu HTTP operācijām

Daudzas populāras kastes, tostarp Reqwest, izmanto Tokio, lai nodrošinātu asinhronas HTTP darbības.

Jūs varat izmantot Tokio kopā ar Reqwest, lai veiktu vairākus HTTP pieprasījumus, nebloķējot citus uzdevumus. Tokio var palīdzēt jums apstrādāt tūkstošiem vienlaicīgu savienojumu un efektīvi pārvaldīt resursus.