Escribir un Future a mano: poll sin magia, con un temporizador

Has visto el trait, el protocolo de poll, el Waker y la máquina que el compilador fabrica. Ahora toca cerrar el nivel de la única forma que fija de verdad un modelo: implementándolo a mano. Vamos a escribir tres futures sin una sola línea de async, empezando por uno trivial que está listo al instante, pasando por un contador que cede reencolándose, y culminando en un temporizador real respaldado por un hilo que, al vencer, llama a wake(). Al terminar habrás construido con tus manos un future hoja —de esos que en la lección anterior eran los únicos que tocan el mundo— y comprobado que debajo de toda la magia async no hay más que una función, poll, y un timbre, wake.

El future más simple: Ready a la primera

Empecemos por el caso degenerado: un future que ya tiene el valor y nunca cede. Su poll devuelve Ready en la primera llamada:

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

struct Listo(u32);

impl Future for Listo {
    type Output = u32;

    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<u32> {
        Poll::Ready(self.0) // termina de inmediato; ni mira el Context
    }
}

Es un future de pleno derecho: cumple el contrato —completa una vez, y como nunca devuelve Pending, no necesita waker—. Ignora cx a propósito: solo quien cede tiene algo que registrar. Esto es, en esencia, lo que hace std::future::ready(x) de la biblioteca. Trivial, pero ya revela la forma: implementar Future es rellenar type Output y escribir un poll.

Un contador que cede: Pending y auto-wake

Subamos un peldaño a un future que sí cede. Un contador que, en cada poll, decrementa y devuelve Pending hasta llegar a cero. Para que lo vuelvan a sondear, se despierta a sí mismo con wake_by_ref():

struct CuentaAtras {
    restantes: u32,
}

impl Future for CuentaAtras {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        let este = self.get_mut(); // valido: CuentaAtras es Unpin
        if este.restantes == 0 {
            Poll::Ready(())
        } else {
            println!("faltan {}", este.restantes);
            este.restantes -= 1;
            cx.waker().wake_by_ref(); // pide ser reencolada de inmediato
            Poll::Pending
        }
    }
}

Aquí ves el ciclo completo latir: el executor sondea, obtiene Pending, y como el future ya llamó a wake_by_ref(), la tarea vuelve enseguida a la cola; el siguiente poll decrementa otra vez, y así hasta el Ready. self.get_mut() nos da el &mut Self para mutar restantes, permitido porque CuentaAtras no es autorreferencial y por tanto es Unpin. Es el esqueleto de un yield: ceder el hilo un instante para que otras tareas avancen, sin esperar nada externo.

Un temporizador de verdad: un hilo y un Waker

Ahora el ejemplo canónico, un future hoja que espera algo externo sin girar. Un temporizador que se completa cuando pasa una duración. La espera la hace un hilo aparte que duerme y, al despertar, marca el estado como completo y dispara el waker que poll dejó guardado. El puente entre el hilo y el future es un Arc<Mutex<...>> compartido:

use std::sync::{Arc, Mutex};
use std::task::Waker;
use std::thread;
use std::time::Duration;

struct Estado {
    completado: bool,
    waker: Option<Waker>,
}

struct Temporizador {
    estado: Arc<Mutex<Estado>>,
}

impl Temporizador {
    fn nuevo(duracion: Duration) -> Self {
        let estado = Arc::new(Mutex::new(Estado { completado: false, waker: None }));
        let compartido = Arc::clone(&estado);
        thread::spawn(move || {
            thread::sleep(duracion);                 // la espera real, fuera del executor
            let mut guardia = compartido.lock().unwrap();
            guardia.completado = true;
            if let Some(waker) = guardia.waker.take() {
                waker.wake();                        // avisa: ya puede avanzar
            }
        });
        Temporizador { estado }
    }
}

impl Future for Temporizador {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        let mut guardia = self.estado.lock().unwrap();
        if guardia.completado {
            Poll::Ready(())
        } else {
            // Guarda SIEMPRE el waker mas reciente antes de ceder.
            guardia.waker = Some(cx.waker().clone());
            Poll::Pending
        }
    }
}

Sigue el baile completo. El primer poll encuentra completado == false, clona y guarda el waker, y devuelve Pending; el executor aparca la tarea y se duerme. En paralelo, el hilo cumple su sleep, pone completado = true y llama a wake(), que reencola la tarea. El executor la sondea otra vez; ahora completado es true y sale Ready(()). Ningún hilo del executor estuvo esperando el tiempo: la espera vivió en un hilo aparte, y el executor solo hizo dos poll baratos separados por un sueño. Cambia ese sleep por un epoll sobre un socket y tienes, en miniatura, cómo funciona un future de red de verdad.

Para conducirlo necesitas un runtime que haga el primer poll; el más simple es block_on:

fn main() {
    // futures::executor::block_on conduce el future hasta Ready.
    futures::executor::block_on(async {
        Temporizador::nuevo(Duration::from_secs(1)).await;
        println!("un segundo despues");
    });
}

flowchart TD
P1[Primer poll completado es false] --> G[Clona y guarda el waker devuelve Pending]
G --> S[El executor aparca la tarea y duerme]
H[Hilo aparte duerme la duracion] --> M[Marca completado true y llama a wake]
M --> Q[El executor reencola la tarea]
Q --> P2[Segundo poll completado es true devuelve Ready]
style P1 fill:#cba6f7,color:#11111b
style G fill:#fab387,color:#11111b
style M fill:#89b4fa,color:#11111b
style P2 fill:#a6e3a1,color:#11111b