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í.
Table of Contents
Asynchronní programování v Rustu
Asynchronní programovací model Rust vám 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.
Také vlastnický model Rust 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áte metodu future poll(), zkontroluje, zda byla budoucnost dokončena nebo zda potřebuje další práci. Pokud budoucnost není připravena, vrátí Poll::Pending, což znamená, že úloha by měla být naplánována na pozdější provedení. Pokud je budoucnost připravena, vrátí Poll::Ready 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í syntaxe async/await pro zpracování asynchronních operací v Rustu budete potřebovat bednu třetí strany. Pro práci se syntaxí async/await můžete použít balíčky třetích stran, jako je Tokio nebo async-std.
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řidejte tokio bednu do sekce závislostí vašeho Cargo.toml 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;async fn hello_world() {
println!("Hello, ");
sleep(Duration::from_secs(1)).await;
println!("World!");
}#[tokio::main]
async fn main() {
hello_world().await;
}
Funkce hello_world je asynchronní, takže může použít klíčové slovo wait k pozastavení jejího provádění, dokud nebude vyřešena budoucnost. Funkce hello_world vytiskne do konzole „Ahoj“. Volání funkce Duration::from_secs(1) pozastaví provádění funkce na sekundu. Klíčové slovo čekání čeká na dokončení spánkové budoucnosti. Nakonec funkce hello_world vypíše „World!“ do konzole.
Hlavní funkce je asynchronní funkce s #[tokio::main] atribut. Označuje hlavní funkci jako vstupní bod pro běhové prostředí Tokio. Funkce hello_world().await 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í prostřednictvím modulu tokio::time.
Zde je návod, jak můžete zpozdit operaci s Tokio runtime:
use std::time::Duration;
use tokio::time::sleep;async fn delayed_operation() {
println!("Performing delayed operation...");
sleep(Duration::from_secs(2)).await;
println!("Delayed operation completed.");
}#[tokio::main]
async fn main() {
println!("Starting...");
delayed_operation().await;
println!("Finished.");
}
Funkce delayed_operation zavádí u metody spánku dvousekundové zpoždění. Funkce delayed_operation 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í typu Result a zpracování chyb Rust pomocí ? operátor.
use tokio::fs::File;
use tokio::io;
use tokio::io::{AsyncReadExt};async fn read_file_contents() -> io::Result<String> {
let mut file = File::open("file.txt").await?;
let mut contents = String::new();
file.read_to_string(&mut contents).await?;
Ok(contents)
}async fn process_file() -> io::Result<()> {
let contents = read_file_contents().await?;
Ok(())
}#[tokio::main]
async fn main() {
match process_file().await {
Ok(()) => println!("File processed successfully."),
Err(err) => eprintln!("Error processing file: {}", err),
}
}
Funkce read_file_contents vrací io::Result, který představuje možnost I/O chyby. Pomocí ? Po každé asynchronní operaci bude runtime Tokio šířit chyby v zásobníku volání.
Hlavní funkce zpracovává výsledek pomocí příkazu shody, 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.