Introduzione ad Async/Await
Impari i fondamenti delle funzioni `async` e delle espressioni `await` per scrivere codice asincrono e non bloccante.
Introduzione ad Async/Await è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 3 lezioni in totale.
Perché la programmazione asincrona?
Nella programmazione, le attività spesso comportano attese. Può trattarsi dell'attesa del caricamento di un file, del completamento di una richiesta di rete o della restituzione dei risultati da parte di una query al database.
Tradizionalmente, i programmi si bloccano durante queste attese, cioè sospendono tutte le altre operazioni finché l'attività non termina. Questo può rendere le applicazioni lente e poco reattive.
Quando il codice attende...
Consideri questo semplice esempio di un'operazione bloccante. Il programma si fermerà per 2 secondi prima di stampare il secondo messaggio.
Provi a eseguirlo:
use std::thread;
use std::time::Duration;
fn main() {
println!("Starting a blocking task...");
thread::sleep(Duration::from_secs(2)); // This blocks!
println!("Blocking task finished!");
}Il costo dell'attesa
Nell'esempio precedente, l'intero programma è rimasto in attesa. Se si trattasse di un server web, significherebbe che, mentre la richiesta di un utente attende il database, non sarebbe possibile servire nessun altro utente!
La programmazione asincrona consente al programma di avviare un'attività di lunga durata e poi passare ad altro lavoro invece di attendere. Quando l'attività lunga è pronta, il programma può riprenderla.
L'approccio asincrono di Rust
Rust offre potenti funzionalità del linguaggio per la programmazione asincrona: le parole chiave async e await.
- Le funzioni
asyncsono funzioni speciali che possono essere sospese e riprese. .awaitviene usato all'interno di una funzioneasyncper attendere il completamento di un'altra attività asincrona senza bloccare l'intero programma.
Definizione di funzioni `async`
Si dichiara una funzione asincrona aggiungendo la parola chiave async prima di fn. Una funzione async restituisce sempre un Future.
Un Future è un valore che potrebbe non essere ancora pronto. Rappresenta un calcolo che produrrà infine un risultato.
async fn my_async_task() -> u32 {
// This task will eventually return 42
42
}Sospensione con `.await`
La parola chiave .await è ciò che rende non bloccante la programmazione asincrona. Quando si usa .await su un Future, la funzione async:
- Sospende la propria esecuzione.
- Consente al programma di svolgere altro lavoro.
- Riprende l'esecuzione quando il Future atteso è pronto.
È come premere il pulsante di pausa sull'attività corrente mentre un'altra attività termina.
Esecuzione del codice asincrono: gli executor
Una funzione async restituisce un Future, ma non esegue immediatamente il codice al suo interno. I Future sono lazy.
Per eseguire effettivamente una funzione async e il relativo Future, è necessario un executor. Per gli esempi semplici, si può usare futures::executor::block_on, che esegue un Future fino al completamento nel thread corrente.
Il primo programma `async`/`await`
Ecco come funzionano insieme async, await e un semplice executor. Noti come block_on venga usato in main per avviare il processo asincrono.
Questo esempio simula un ritardo asincrono senza bloccare il thread della funzione main (concettualmente; block_on blocca comunque l'esecuzione finché il future non è completato, ma l'attività asincrona cede il controllo).
use futures::executor::block_on;
use std::time::Duration;
async fn learn_and_wait() {
println!("Learning asynchronously...");
// Simulate an async operation that takes time
// In a real app, this would be an I/O op
tokio::time::sleep(Duration::from_secs(1)).await;
println!("Finished learning!");
}
fn main() {
println!("Starting main function.");
block_on(learn_and_wait());
println!("Main function finished.");
}Comprendere il trait `Future`
Quando si scrive async fn my_func(), Rust lo trasforma in realtà in una macchina a stati che implementa il trait Future.
Il trait Future ha un metodo principale, poll, che un executor chiama ripetutamente per verificare se l'attività è pronta a progredire. Quando si usa .await su un Future, questo indica all'executor di eseguire il polling di un altro Future finché non è terminato.
Verifica rapida: nozioni di base su Async/Await
Ha appreso le nozioni di base di async e await. Verifichiamo se sa riconoscerne i ruoli principali.
Riepilogo e prossimi passi
Ottimo lavoro! Ha mosso i primi passi nella programmazione asincrona con Rust.
- Ha visto che il codice sincrono si blocca, costringendo i programmi ad attendere.
- Il codice asincrono consente alle attività di essere eseguite concorrentemente senza bloccare il programma.
- La parola chiave
asyncdichiara una funzione asincrona, che restituisce un Future. - La parola chiave
.awaitsospende una funzioneasyncfinché un Future non è pronto. - Per eseguire i Future è necessario un executor (come
block_on).
Ora approfondiremo Tokio, un potente runtime ed ecosistema per creare applicazioni asincrone reali in Rust!
Domande Frequenti
La lezione «Introduzione ad Async/Await» è gratuita?
Sì — il testo completo di «Introduzione ad Async/Await» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 3 lezioni in totale.
Cosa imparerò in «Introduzione ad Async/Await»?
Impari i fondamenti delle funzioni `async` e delle espressioni `await` per scrivere codice asincrono e non bloccante. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.
Quanto tempo richiede la lezione «Introduzione ad Async/Await»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Introduzione ad Async/Await
- Creare applicazioni asincrone con Tokio
- Lavorare con Future e task