Programmazione asincrona in Rust

In questo articolo vediamo due esempi di programmazione asincrona in Rust.

In entrambi i casi useremo tokio!

Possiamo aggiungerla al Cargo.toml:

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

Un primo esempio è molto basico:

use std::time::Duration;
use tokio::time::sleep;

#[tokio::main]
async fn main() {
    println!("Inizio!");
    sleep(Duration::from_secs(5)).await;
    println!("Fine dopo i 5 secondi!");
}

Come vedete non facciamo altro che stampare due stringhe, aspettando 5 secondi tra un e l'altra.

Per un esempio più concreto creeremo un classico contatore, ma useremo anche Future:

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

struct ContatoreFuture {
    cnt: u32,
    cnt_finale: u32,
}

impl ContatoreFuture {
    pub fn new(valore_finale: u32) -> Self {
        Self {
            cnt: 0,
            cnt_finale: valore_finale,
        }
    }
}

impl Future for ContatoreFuture {
    type Output = u32;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<u32> {
        self.cnt += 1;

        println!("Cnt: {}", self.cnt);

        if self.cnt >= self.cnt_finale {
            println!("Fine!");
            return Poll::Ready(self.cnt_finale);
        }

        cx.waker().wake_by_ref();
        Poll::Pending
    }
}

#[tokio::main]
async fn main() {
    let contatore = ContatoreFuture::new(1000);

    let valore_finale = contatore.await;
    println!("Valore finale: {}", valore_finale);
}

Prime di arrivare alla fine dell'esecuzione, verranno stampati in numeri; poi la fine del conteggio, e poi la fine dell'esecuzione (il valore finale).

Enjoy!