Un'introduzione alla programmazione asincrona in Rust

I tradizionali modelli di programmazione sincrona spesso portano a colli di bottiglia nelle prestazioni. Questo perché il programma attende il completamento delle operazioni lente prima di passare all'attività successiva. Ciò si traduce spesso in uno scarso utilizzo delle risorse e in un'esperienza utente lenta.

La programmazione asincrona consente di scrivere codice non bloccante che utilizza le risorse di sistema in modo efficace. Sfruttando la programmazione asincrona, puoi progettare app che eseguono più attività. La programmazione asincrona è utile per gestire diverse richieste di rete o elaborare grandi quantità di dati senza bloccare il flusso di esecuzione.

Programmazione asincrona in Rust

Il modello di programmazione asincrona di Rust te lo consente scrivere codice Rust efficiente che viene eseguito contemporaneamente senza bloccare il flusso di esecuzione. La programmazione asincrona è vantaggiosa quando si gestiscono operazioni di I/O, richieste di rete e attività che comportano l'attesa di risorse esterne.

Puoi implementare la programmazione asincrona nelle tue app Rust in diversi modi. Questi includono funzionalità linguistiche, librerie e il runtime Tokio.

Anche, Il modello di proprietà di Rust e primitive di concorrenza come canali e blocchi consentono una programmazione concorrente sicura ed efficiente. Puoi sfruttare queste funzionalità con la programmazione asincrona per creare sistemi simultanei in grado di scalare bene e utilizzare più core della CPU.

Concetti di programmazione asincrona di Rust

I future forniscono una base per la programmazione asincrona in Rust. Un futuro rappresenta un calcolo asincrono che non è stato completamente eseguito.

I futures sono pigri (vengono eseguiti solo durante il polling). Quando chiami futuro sondaggio() metodo, controlla se il futuro è stato completato o necessita di ulteriore lavoro. Se il futuro non è pronto, ritorna Sondaggio:: In attesa, che indica che l'attività deve essere pianificata per un'esecuzione successiva. Se il futuro è pronto, ritorna Sondaggio:: Pronto con il valore risultante.

La toolchain standard di Rust include primitive I/O asincrone, una versione asincrona di file I/O, networking e timer. Queste primitive consentono di eseguire operazioni di I/O in modo asincrono. Ciò consente di evitare di bloccare l'esecuzione di un programma durante l'attesa del completamento delle attività di I/O.

La sintassi async/await consente di scrivere codice asincrono simile al codice sincrono. Ciò rende il codice intuitivo e facile da mantenere.

L'approccio di Rust alla programmazione asincrona enfatizza la sicurezza e le prestazioni. Le regole di proprietà e prestito garantiscono la sicurezza della memoria e impediscono problemi di concorrenza comuni. Async/await syntax e futures forniscono un modo intuitivo per esprimere flussi di lavoro asincroni. È possibile utilizzare un runtime di terze parti per gestire le attività per un'esecuzione efficiente.

Puoi combinare queste funzionalità del linguaggio, librerie e runtime per scrivere codice ad alte prestazioni. Fornisce un framework potente ed ergonomico per la creazione di sistemi asincroni. Ciò rende Rust una scelta popolare per i progetti che richiedono una gestione efficiente delle attività legate all'I/O e un'elevata concorrenza.

Rust versione 1.39 e versioni successive non supportano le operazioni asincrone nella libreria standard di Rust. Avrai bisogno di una cassa di terze parti per utilizzare il asincrono/aspetta sintassi per la gestione delle operazioni asincrone in Rust. Puoi usare pacchetti di terze parti come Tokyo O async-std per lavorare con la sintassi async/await.

Programmazione asincrona con Tokio

Tokio è un robusto runtime asincrono per Rust. Fornisce funzionalità per la creazione di applicazioni altamente performanti e scalabili. Puoi sfruttare la potenza della programmazione asincrona con Tokio. Fornisce inoltre funzionalità per l'estensibilità.

Al centro di Tokio c'è la pianificazione asincrona delle attività e il modello di esecuzione. Tokio ti permette di scrivere codice asincrono con la sintassi async/await. Ciò consente un utilizzo efficiente delle risorse di sistema e l'esecuzione simultanea delle attività. Il ciclo di eventi di Tokio gestisce in modo efficiente la pianificazione delle attività. Ciò garantisce un utilizzo ottimale dei core della CPU e riduce al minimo l'overhead dovuto al cambio di contesto.

I combinatori di Tokio semplificano il coordinamento e la composizione dei compiti. Tokio fornisce potenti strumenti di coordinamento e composizione delle attività. Puoi attendere il completamento di più attività con join, selezionare la prima attività completata con select e gareggiare le attività l'una contro l'altra con race.

Aggiungi il tokio cassa al tuo Cargo.toml sezione delle dipendenze del file.

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

Ecco come puoi usare la sintassi async/await nei tuoi programmi Rust con 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;
}

IL Ciao mondo La funzione è asincrona, quindi può utilizzare il aspetta parola chiave per sospenderne l'esecuzione fino a quando non viene risolto un futuro. IL Ciao mondo stampe di funzioni "Ciao, " alla consolle. IL Durata:: da_sec (1) chiamata di funzione sospende l'esecuzione della funzione per un secondo. IL aspetta la parola chiave attende il completamento dello sleep future. Infine il Ciao mondo stampe di funzioni "Mondo!" alla consolle.

IL principale funzione è una funzione asincrona con il #[tokio:: principale] attributo. Designa la funzione principale come punto di ingresso per il runtime di Tokio. IL ciao_mondo().aspetta esegue la funzione hello_world in modo asincrono.

Ritardare le attività con Tokio

Un'attività prevalente nella programmazione asincrona utilizza ritardi o attività di pianificazione per l'esecuzione in un intervallo di tempo specificato. Il runtime tokio fornisce un meccanismo per l'utilizzo di timer asincroni e ritardi attraverso il tokio:: tempo modulo.

Ecco come puoi ritardare un'operazione con il runtime di 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.");
}

IL operazione_ritardata La funzione introduce un ritardo di due secondi con il sonno metodo. IL operazione_ritardata La funzione è asincrona, quindi può utilizzare await per sospenderne l'esecuzione fino al completamento del ritardo.

Gestione degli errori nei programmi asincroni

La gestione degli errori nel codice Rust asincrono comporta l'utilizzo di Risultato tipo e gestire gli errori di Rust con il ? operatore.

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

IL read_file_contents funzione restituisce un io:: Risultato che rappresenta la possibilità di un errore di I/O. Utilizzando il ? operatore dopo ogni operazione asincrona, il runtime Tokio propagherà gli errori nello stack di chiamate.

IL principale la funzione gestisce il risultato con a incontro istruzione che stampa un testo in base al risultato dell'operazione.

Reqwest utilizza la programmazione asincrona per le operazioni HTTP

Molte casse popolari, incluso Reqwest, usano Tokio per fornire operazioni HTTP asincrone.

Puoi utilizzare Tokio con Reqwest per effettuare diverse richieste HTTP senza bloccare altre attività. Tokio può aiutarti a gestire migliaia di connessioni simultanee e gestire in modo efficiente le risorse.