Asynchrone programmering is een belangrijk concept waar je je als Rust-ontwikkelaar bewust van moet zijn.
Traditionele synchrone programmeermodellen leiden vaak tot prestatieknelpunten. Dit komt omdat het programma wacht tot trage bewerkingen zijn voltooid voordat het verdergaat met de volgende taak. Dit resulteert vaak in slecht gebruik van bronnen en een trage gebruikerservaring.
Met asynchroon programmeren kunt u niet-blokkerende code schrijven die systeembronnen effectief gebruikt. Door gebruik te maken van asynchrone programmering kunt u apps ontwerpen die meerdere taken uitvoeren. Asynchrone programmering is handig voor het afhandelen van meerdere netwerkverzoeken of het verwerken van grote hoeveelheden gegevens zonder de uitvoeringsstroom te blokkeren.
Asynchrone programmering in Rust
Het asynchrone programmeermodel van Rust stelt u in staat om schrijf efficiënte Rust-code die gelijktijdig wordt uitgevoerd zonder de uitvoeringsstroom te blokkeren. Asynchrone programmering is handig bij het omgaan met I/O-bewerkingen, netwerkverzoeken en taken waarbij moet worden gewacht op externe bronnen.
U kunt op verschillende manieren asynchrone programmering in uw Rust-apps implementeren. Deze omvatten taalfuncties, bibliotheken en de Tokio-runtime.
Ook, Het eigendomsmodel van Rust en gelijktijdigheidsprimitieven zoals kanalen en vergrendelingen maken veilige en efficiënte gelijktijdige programmering mogelijk. U kunt deze functies benutten met asynchrone programmering om gelijktijdige systemen te bouwen die goed schaalbaar zijn en meerdere CPU-kernen gebruiken.
Rust's concepten voor asynchrone programmering
Futures bieden een basis voor asynchrone programmering in Rust. Een toekomst vertegenwoordigt een asynchrone berekening die niet volledig is uitgevoerd.
Futures zijn lui (ze worden alleen uitgevoerd tijdens de peiling). Wanneer je een toekomst noemt peiling() methode wordt gecontroleerd of de toekomst is voltooid of nog moet worden gewerkt. Als de toekomst niet klaar is, keert ze terug Poll:: In afwachting, waarmee wordt aangegeven dat de taak moet worden gepland voor latere uitvoering. Als de toekomst klaar is, keert ze terug Poll:: Klaar met de resulterende waarde.
De standaard toolchain van Rust omvat asynchrone I/O-primitieven, een asynchrone versie van bestands-I/O, netwerken en timers. Met deze primitieven kunt u I/O-bewerkingen asynchroon uitvoeren. Dit helpt voorkomen dat de uitvoering van een programma wordt geblokkeerd terwijl wordt gewacht tot de I/O-taken zijn voltooid.
Met de async/wait-syntaxis kunt u asynchrone code schrijven die lijkt op synchrone code. Dit maakt uw code intuïtief en gemakkelijk te onderhouden.
Rust's benadering van asynchrone programmering legt de nadruk op veiligheid en prestaties. De eigendoms- en leenregels zorgen voor geheugenveiligheid en voorkomen veelvoorkomende gelijktijdigheidsproblemen. Async/wait-syntaxis en futures bieden een intuïtieve manier om asynchrone workflows uit te drukken. U kunt een runtime van derden gebruiken om taken te beheren voor een efficiënte uitvoering.
U kunt deze taalfuncties, bibliotheken en runtime combineren om zeer krachtige code te schrijven. Het biedt een krachtig en ergonomisch raamwerk voor het bouwen van asynchrone systemen. Dit maakt Rust een populaire keuze voor projecten die een efficiënte afhandeling van I/O-gebonden taken en hoge gelijktijdigheid vereisen.
Rust versie 1.39 en latere releases ondersteunen geen asynchrone bewerkingen in de standaardbibliotheek van Rust. Je hebt een krat van derden nodig om de asynchroon/wachten syntaxis voor het afhandelen van asynchrone bewerkingen in Rust. U kunt pakketten van derden gebruiken, zoals Tokio of asynchrone standaard om te werken met de syntaxis async/wait.
Asynchrone programmering met Tokio
Tokio is een robuuste asynchrone runtime voor Rust. Het biedt functionaliteit voor het bouwen van zeer krachtige en schaalbare applicaties. U kunt de kracht van asynchrone programmering benutten met Tokio. Het biedt ook functies voor uitbreidbaarheid.
De kern van Tokio is het asynchrone taakplannings- en uitvoeringsmodel. Met Tokio kun je asynchrone code schrijven met de async/wait-syntaxis. Dit maakt efficiënt gebruik van systeembronnen en gelijktijdige uitvoering van taken mogelijk. De evenementenlus van Tokio beheert efficiënt de taakplanning. Dit zorgt voor een optimaal gebruik van CPU-kernen en minimaliseert overhead voor contextwisseling.
Tokio's combinators maken taakcoördinatie en samenstelling eenvoudig. Tokio biedt krachtige tools voor taakcoördinatie en compositie. Je kunt wachten tot meerdere taken zijn voltooid met meedoen, de eerste voltooide taak selecteren met selecteren en taken tegen elkaar racen met racen.
Voeg de Tokio krat naar je toe Cargo.toml sectie afhankelijkheden van het bestand.
[dependencies]
tokio = { version = "1.9", features = ["full"] }
Hier leest u hoe u de async/wait-syntaxis kunt gebruiken in uw Rust-programma's met 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;
}
De Hallo Wereld functie is asynchroon, dus het kan de wachten trefwoord om de uitvoering ervan te onderbreken totdat een toekomst is opgelost. De Hallo Wereld functie wordt afgedrukt "Hallo, " naar de console. De Duur:: from_secs (1) functieaanroep onderbreekt de uitvoering van de functie gedurende een seconde. De wachten trefwoord wacht tot de slaaptoekomst is voltooid. eindelijk, de Hallo Wereld functie wordt afgedrukt "Wereld!" naar de console.
De voornaamst functie is een asynchrone functie met de #[tokio:: hoofd] attribuut. Het wijst de hoofdfunctie aan als het startpunt voor de Tokio-runtime. De hallo_world().wacht voert de functie hello_world asynchroon uit.
Taken uitstellen met Tokio
Een veelvoorkomende taak bij asynchrone programmering is het gebruik van vertragingen of planningstaken die binnen een bepaald tijdsbestek worden uitgevoerd. De tokio-runtime biedt een mechanisme voor het gebruik van asynchrone timers en vertragingen via de tokio:: tijd moduul.
Zo kunt u een bewerking vertragen met de 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.");
}
De vertraagde_operatie functie introduceert een vertraging van twee seconden met de slaap methode. De vertraagde_operatie functie is asynchroon, dus het kan wachten gebruiken om de uitvoering ervan te pauzeren totdat de vertraging is voltooid.
Foutafhandeling in asynchrone programma's
Foutafhandeling in asynchrone Rust-code omvat het gebruik van de Resultaat typ en omgaan met roestfouten met de ? exploitant.
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),
}
}
De read_file_contents functie retourneert een io:: Resultaat dat vertegenwoordigt de mogelijkheid van een I/O-fout. Door gebruik te maken van de ? operator na elke asynchrone bewerking, zal de Tokio-runtime fouten doorgeven aan de call-stack.
De voornaamst functie verwerkt het resultaat met a overeenkomst instructie die een tekst afdrukt op basis van de uitkomst van de bewerking.
Reqwest gebruikt asynchrone programmering voor HTTP-bewerkingen
Veel populaire kratten, waaronder Reqwest, gebruiken Tokio om asynchrone HTTP-bewerkingen uit te voeren.
U kunt Tokio met Reqwest gebruiken om verschillende HTTP-verzoeken te doen zonder andere taken te blokkeren. Tokio kan u helpen bij het afhandelen van duizenden gelijktijdige verbindingen en het efficiënt beheren van bronnen.