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:
- Los futuros no hacen nada hasta que se sondean. Llamar a una función async devuelve un valor; tienes que hacerle
.awaito entregárselo a un ejecutor. - Rust no tiene un runtime incorporado. La biblioteca estándar define
Future; un ejecutor —Tokio, smol, embassy en microcontroladores— decide cuándo sondear. - Un futuro
Pendingdebe encargarse de que lo despierten. ElContextlleva unWaker; cuando el socket pasa a ser legible, el reactor llama awake()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());
}
.awaitejecuta 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::spawncrea una tarea independiente. Igual quethread::spawn, necesita un futuroSend + '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, otokio::task::spawn_blockingpara el bloqueo inevitable y el trabajo intensivo de CPU. - No mantengas una guarda de
std::sync::Mutexa través de un.await. La tarea puede quedar suspendida mientras tiene el cerrojo. O lo sueltas antes, o usastokio::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
Senden un runtime multihilo. Mantener unRco una guarda que no esSenda través de un await hace que todo el futuro deje de serSend, 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
- 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 contokio::sync::Semaphore. - 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. - 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 unJoinSet. - Explica por qué
let g = std_mutex.lock().unwrap(); other().await;hace que un futuro no seaSend, y da dos formas de arreglarlo.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué hace llamar a una
async fn?2.¿Por qué no debes llamar a una función bloqueante como
std::thread::sleepdentro de una tarea async?3.¿Qué le ocurre a un futuro que se libera antes de completarse?