Correr futuros juntos en Rust

join! espera varios futuros a la vez; try_join! abandona en el primer error.

use tokio::time::{sleep, Duration};

async fn latency(ms: u64) -> u64 {
    sleep(Duration::from_millis(ms)).await;
    ms
}

async fn checked(ms: u64) -> Result<u64, String> {
    if ms > 100 {
        return Err(format!("{ms}ms is too slow"));
    }
    Ok(latency(ms).await)
}

#[tokio::main]
async fn main() {
    let (a, b, c) = tokio::join!(latency(30), latency(10), latency(20));
    println!("{a} {b} {c}");

    let result = tokio::try_join!(checked(20), checked(500));
    println!("{:?}", result);
}

Cómo funciona

1. join! sondea todos los futuros de forma concurrente en una tarea.
2. Los resultados vuelven como una tupla, en orden.
3. try_join! corta en corto cuando uno devuelve Err.

Palabras clave y builtins usados aquí

• Err
• Ok
• Result
• String
• async
• await
• fn
• if
• let
• return
• u64
• use

El intento, en números

Líneas

22

Caracteres a escribir

466

Tokens

155

Ritmo de tres estrellas

110 tpm

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

Escribe este fragmento

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

← Anterior Siguiente →