Asynchronní programování je důležitý koncept, kterého si jako vývojář Rust musíte být vědomi.

Tradiční modely synchronního programování často vedou k omezení výkonu. Je to proto, že program čeká na dokončení pomalých operací, než přejde k další úloze. To často vede ke špatnému využití zdrojů a pomalému uživatelskému dojmu.

Asynchronní programování umožňuje psát neblokující kód, který efektivně využívá systémové prostředky. Využitím asynchronního programování můžete navrhovat aplikace, které provádějí více úkolů. Asynchronní programování je užitečné pro zpracování několika síťových požadavků nebo zpracování velkého množství dat bez blokování toku provádění.

Asynchronní programování v Rustu

Asynchronní programovací model Rust vám to umožňuje psát efektivní kód Rust, který běží souběžně bez blokování toku provádění. Asynchronní programování je výhodné při řešení I/O operací, síťových požadavků a úloh, které zahrnují čekání na externí zdroje.

Asynchronní programování můžete ve svých aplikacích Rust implementovat několika způsoby. Patří mezi ně jazykové funkce, knihovny a běhové prostředí Tokio.

instagram viewer

Taky, Rustův model vlastnictví a primitiva souběžnosti, jako jsou kanály a zámky, umožňují bezpečné a efektivní souběžné programování. Tyto funkce můžete využít pomocí asynchronního programování k vytvoření souběžných systémů, které se dobře škálují a využívají více jader CPU.

Rustovy koncepty asynchronního programování

Futures poskytují základ pro asynchronní programování v Rustu. Budoucnost představuje asynchronní výpočet, který nebyl zcela proveden.

Futures jsou líné (provádějí se pouze při hlasování). Když zavoláš budoucnost hlasování() zkontroluje, zda byla budoucnost dokončena nebo zda potřebuje další práci. Pokud budoucnost není připravena, vrací se Anketa:: Čeká na vyřízení, což znamená, že úloha by měla být naplánována na pozdější provedení. Pokud je budoucnost připravena, vrací se Anketa:: Připraveno s výslednou hodnotou.

Standardní sada nástrojů Rust zahrnuje asynchronní I/O primitiva, asynchronní verzi souborových I/O, sítě a časovače. Tato primitiva umožňují provádět I/O operace asynchronně. To pomáhá vyhnout se blokování provádění programu při čekání na dokončení I/O úloh.

Syntaxe async/await umožňuje psát asynchronní kód, který vypadá podobně jako synchronní kód. Díky tomu je váš kód intuitivní a snadno se udržuje.

Rustův přístup k asynchronnímu programování klade důraz na bezpečnost a výkon. Pravidla vlastnictví a půjčování zajišťují bezpečnost paměti a zabraňují běžným problémům se souběžným zpracováním. Syntaxe async/wait a futures poskytují intuitivní způsob, jak vyjádřit asynchronní pracovní postupy. Ke správě úloh pro efektivní provádění můžete použít runtime třetí strany.

Tyto jazykové funkce, knihovny a běhové prostředí můžete kombinovat a psát vysoce výkonný kód. Poskytuje výkonný a ergonomický rámec pro budování asynchronních systémů. Díky tomu je Rust oblíbenou volbou pro projekty vyžadující efektivní zpracování I/O-vázaných úloh a vysokou souběžnost.

Rust verze 1.39 a novější verze nepodporují asynchronní operace ve standardní knihovně Rust. K použití budete potřebovat bednu třetí strany asynchronní/čekat syntaxe pro zpracování asynchronních operací v Rust. Můžete použít balíčky třetích stran jako např Tokio nebo async-std pracovat se syntaxí async/wait.

Asynchronní programování s Tokiem

Tokio je robustní asynchronní runtime pro Rust. Poskytuje funkce pro vytváření vysoce výkonných a škálovatelných aplikací. S Tokio můžete využít sílu asynchronního programování. Poskytuje také funkce pro rozšiřitelnost.

Jádrem Tokia je jeho asynchronní model plánování a provádění úloh. Tokio vám umožňuje psát asynchronní kód se syntaxí async/await. To umožňuje efektivní využití systémových prostředků a souběžné provádění úloh. Tokio událostní smyčka efektivně řídí plánování úkolů. To zajišťuje optimální využití jader CPU a minimalizuje režii přepínání kontextu.

Tokio kombinátory usnadňují koordinaci a složení úkolů. Tokio poskytuje výkonné nástroje pro koordinaci úkolů a kompozici. Můžete počkat na dokončení více úkolů s připojením, vybrat první splněný úkol s výběrem a závodit proti sobě s rasou.

Přidat tokio přepravka do vašeho Cargo.toml sekce závislostí souboru.

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

Zde je návod, jak můžete použít syntaxi async/await ve vašich programech Rust s 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 Ahoj světe funkce je asynchronní, takže může používat čekat klíčové slovo pro pozastavení jeho provádění, dokud nebude vyřešena budoucnost. The Ahoj světe funkce tiskne "Ahoj, " do konzole. The Délka:: from_secs (1) volání funkce pozastaví provádění funkce na sekundu. The čekat klíčové slovo čeká na dokončení budoucího spánku. Konečně, Ahoj světe funkce tiskne "Svět!" do konzole.

The hlavní funkce je asynchronní funkce s #[tokio:: hlavní] atribut. Označuje hlavní funkci jako vstupní bod pro běhové prostředí Tokio. The ahoj_svět().čekej provádí funkci hello_world asynchronně.

Odkládání úkolů s Tokiem

Převládající úlohou v asynchronním programování je použití zpoždění nebo plánování úloh ke spuštění v určeném časovém rozsahu. Runtime tokio poskytuje mechanismus pro použití asynchronních časovačů a zpoždění přes tokio:: čas modul.

Zde je návod, jak můžete zpozdit operaci s Tokio runtime:

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 zpožděná_operace funkce zavádí zpoždění dvou sekund s spát metoda. The zpožděná_operace funkce je asynchronní, takže může použít funkci čekání k pozastavení jejího provádění, dokud nebude zpoždění dokončeno.

Zpracování chyb v asynchronních programech

Zpracování chyb v asynchronním kódu Rust zahrnuje použití Výsledek typu a zpracování chyb Rust s ? operátor.

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 read_file_contents funkce vrací an io:: Výsledek což představuje možnost I/O chyby. Pomocí ? Po každé asynchronní operaci bude runtime Tokio šířit chyby v zásobníku volání.

The hlavní funkce zpracovává výsledek s a zápas příkaz, který vytiskne text na základě výsledku operace.

Reqwest používá asynchronní programování pro operace HTTP

Mnoho populárních přepravek, včetně Reqwest, používá Tokio k poskytování asynchronních HTTP operací.

Můžete použít Tokio s Reqwest k vytvoření několika HTTP požadavků bez blokování jiných úloh. Tokio vám může pomoci zvládnout tisíce souběžných připojení a efektivně spravovat zdroje.