FerrousPath

Nivel 3 · Sistemas· Lección 2 de 11 · 35 min

Async y await

Los futuros como máquinas de estados, ejecutores, tareas, cancelación y cómo escribir E/S concurrente con Tokio.

Por qué async

Un hilo por conexión funciona hasta que tienes decenas de miles de conexiones: cada hilo cuesta memoria de pila y cambios de contexto. Async permite que un solo hilo haga malabares con muchas tareas que pasan la mayor parte del tiempo esperando: a la red, a un temporizador, a un disco. Es una herramienta para la concurrencia limitada por la E/S. Para el trabajo limitado por la CPU, los hilos o Rayon siguen siendo la elección correcta.

Los futuros son máquinas de estados perezosas

pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

pub enum Poll<T> { Ready(T), Pending }

Una async fn se compila a un tipo anónimo que implementa Future. Cada .await es un punto donde la función puede pausarse; el compilador transforma el cuerpo en un enum con una variante por cada punto de pausa, que mantiene vivas las variables locales a través de él. No hay ninguna reserva oculta en el heap ni una pila separada por tarea.

Tres consecuencias:

  1. Los futuros no hacen nada hasta que se sondean. Llamar a una función async devuelve un valor; tienes que hacerle .await o entregárselo a un ejecutor.
  2. Rust no tiene un runtime incorporado. La biblioteca estándar define Future; un ejecutor —Tokio, smol, embassy en microcontroladores— decide cuándo sondear.
  3. Un futuro Pending debe encargarse de que lo despierten. El Context lleva un Waker; cuando el socket pasa a ser legible, el reactor llama a wake() y el ejecutor vuelve a sondear esa tarea.

El nivel 4 construye un ejecutor desde cero. Aquí usamos Tokio.

Tareas y join!

// crate: tokio
use std::time::{Duration, Instant};
use tokio::time::sleep;

async fn fetch(name: &str, ms: u64) -> String {
    sleep(Duration::from_millis(ms)).await; // cede el control al ejecutor
    format!("{name} done after {ms} ms")
}

#[tokio::main]
async fn main() {
    let start = Instant::now();

    // Secuencial: 300 ms.
    let a = fetch("a", 100).await;
    let b = fetch("b", 200).await;
    println!("{a}; {b}; elapsed {:?}", start.elapsed());

    // Concurrente en una sola tarea: ~200 ms.
    let start = Instant::now();
    let (a, b) = tokio::join!(fetch("a", 100), fetch("b", 200));
    println!("{a}; {b}; elapsed {:?}", start.elapsed());

    // Las tareas lanzadas pueden ejecutarse en paralelo en el grupo de hilos de trabajo.
    let start = Instant::now();
    let handles: Vec<_> = (1..=5u64)
        .map(|i| tokio::spawn(async move { fetch("task", i * 40).await }))
        .collect();
    for h in handles {
        println!("{}", h.await.unwrap());
    }
    println!("elapsed {:?}", start.elapsed());
}
  • .await ejecuta un futuro hasta completarlo antes de pasar a la línea siguiente.
  • join! sondea varios futuros de forma concurrente dentro de la tarea actual.
  • tokio::spawn crea una tarea independiente. Igual que thread::spawn, necesita un futuro Send + 'static.

select!, tiempos de espera y cancelación

// crate: tokio
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::time::{sleep, timeout};

async fn slow() -> u32 {
    sleep(Duration::from_secs(5)).await;
    42
}

#[tokio::main]
async fn main() {
    // Un timeout no es más que «enfrenta el futuro a un temporizador y libera al perdedor».
    match timeout(Duration::from_millis(100), slow()).await {
        Ok(v) => println!("got {v}"),
        Err(_) => println!("timed out; `slow` was dropped mid-sleep"),
    }

    let (tx, mut rx) = mpsc::channel::<u32>(8);
    tokio::spawn(async move {
        for i in 0..3 {
            sleep(Duration::from_millis(30)).await;
            if tx.send(i).await.is_err() {
                break;
            }
        }
    });

    let deadline = sleep(Duration::from_millis(200));
    tokio::pin!(deadline);
    loop {
        tokio::select! {
            Some(v) = rx.recv() => println!("received {v}"),
            _ = &mut deadline => { println!("deadline"); break; }
            else => { println!("channel closed"); break; }
        }
    }
}

Cancelar es liberar. Cuando select! elige una rama, los demás futuros se liberan allí donde estén. Un futuro puede detenerse en cualquier .await y no reanudarse nunca. El código que mantiene un invariante a medias a través de un await —«he quitado el elemento de la cola pero todavía no lo he escrito»— no es seguro ante la cancelación (cancel-safe). Consulta la documentación de todo lo que uses dentro de select!.

Las reglas del Rust asíncrono

  • Nunca bloquees el ejecutor. Nada de std::thread::sleep, ni llamadas bloqueantes a archivos o a la red, ni cálculos largos dentro de una tarea. Usa los equivalentes async, o tokio::task::spawn_blocking para el bloqueo inevitable y el trabajo intensivo de CPU.
  • No mantengas una guarda de std::sync::Mutex a través de un .await. La tarea puede quedar suspendida mientras tiene el cerrojo. O lo sueltas antes, o usas tokio::sync::Mutex, cuya guarda sí se puede mantener a través de un await. Para secciones críticas cortas sin ningún await dentro, el mutex estándar es más rápido y es correcto.
  • Los futuros lanzados deben ser Send en un runtime multihilo. Mantener un Rc o una guarda que no es Send a través de un await hace que todo el futuro deje de ser Send, y el mensaje de error señala el await.
  • Acota tu concurrencia. Los canales sin límite y lanzar tareas sin límite convierten la carga en agotamiento de memoria. Prefiere los canales acotados y Semaphore.

Traits y clausuras async

async fn en traits es estable desde Rust 1.75, y las clausuras async (async |x| …) desde la 1.85:

// crate: tokio
trait Store {
    async fn get(&self, key: &str) -> Option<String>;
}

struct Memory;

impl Store for Memory {
    async fn get(&self, key: &str) -> Option<String> {
        (key == "answer").then(|| "42".to_string())
    }
}

async fn lookup(store: &impl Store, key: &str) -> String {
    store.get(key).await.unwrap_or_else(|| "missing".into())
}

#[tokio::main]
async fn main() {
    println!("{} {}", lookup(&Memory, "answer").await, lookup(&Memory, "x").await);
}

Un trait con async fn todavía no se puede usar directamente como dyn Trait, porque cada implementación devuelve un tipo de futuro distinto. Para el despacho dinámico, devuelve explícitamente Pin<Box<dyn Future<Output = T> + Send + '_>> o usa el crate async-trait.

Streams

Un Stream es el equivalente async de Iterator: produce una secuencia de valores, cada uno de los cuales puede requerir una espera. El trait vive en futures / tokio-stream y se usa con while let Some(item) = stream.next().await.

Ejercicios

  1. Escribe una función async que obtenga tres «URL» (simuladas con sleep) de forma concurrente y devuelva los resultados en orden. Después limítala a dos a la vez con tokio::sync::Semaphore.
  2. Construye un servidor de eco TCP con tokio::net::TcpListener: acepta conexiones en un bucle, lanza (spawn) una tarea por conexión y devuelve los bytes recibidos.
  3. Añade un apagado ordenado: al recibir tokio::signal::ctrl_c(), deja de aceptar conexiones y espera a las que estén en curso usando un JoinSet.
  4. Explica por qué let g = std_mutex.lock().unwrap(); other().await; hace que un futuro no sea Send, y da dos formas de arreglarlo.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué hace llamar a una async fn?

  2. 2.¿Por qué no debes llamar a una función bloqueante como std::thread::sleep dentro de una tarea async?

  3. 3.¿Qué le ocurre a un futuro que se libera antes de completarse?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?