Sostener un lock a través de un await en Rust

El Mutex de tokio puede sostenerse a través de un await; el de std, no.

use std::sync::Arc;
use tokio::sync::Mutex;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let log = Arc::new(Mutex::new(Vec::new()));
    let mut tasks = Vec::new();

    for id in 0..3 {
        let log = Arc::clone(&log);
        tasks.push(tokio::spawn(async move {
            let mut entries = log.lock().await;
            sleep(Duration::from_millis(5)).await;
            entries.push(id);
        }));
    }

    for t in tasks {
        t.await.unwrap();
    }

    let mut entries = log.lock().await.clone();
    entries.sort();
    println!("{:?}", entries);
}

Cómo funciona

1. Un lock async cede en vez de bloquear el hilo.
2. Usa el Mutex de std cuando la sección crítica no tiene await.
3. Arc sigue aportando la propiedad compartida.

Palabras clave y builtins usados aquí

• Vec
• async
• await
• fn
• for
• in
• let
• move
• mut
• use

El intento, en números

Líneas

26

Caracteres a escribir

496

Tokens

175

Ritmo de tres estrellas

110 tpm

Al ritmo de tres estrellas de 110 tokens por minuto, este intento toma unos 95 segundos.

Escribe este fragmento

Paso 6 de 6 en Async con tokio; paso 14 de 15 en Concurrencia y async.

← Anterior Siguiente →