longio 0.0.1

一个极简异步运行时
Documentation
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::future::Future;
use std::pin::Pin;
use std::rc::Rc;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
use std::thread;
use std::time::{Duration, Instant};

// 任务就是一个无返回值的、堆上 pin 住的 future
type BoxFuture = Pin<Box<dyn Future<Output = ()> + 'static>>;

// ---------- Waker ----------
// 所谓的"唤醒", 只是把任务 id 塞回 channel, 让事件循环再去 poll 它一次。
static WAKER_VTABLE: RawWakerVTable =
    RawWakerVTable::new(clone_raw, wake_raw, wake_by_ref_raw, drop_raw);

fn make_waker(id: usize, tx: Sender<usize>) -> Waker {
    let data = Box::into_raw(Box::new((id, tx))) as *const ();
    unsafe { Waker::from_raw(RawWaker::new(data, &WAKER_VTABLE)) }
}

unsafe fn clone_raw(data: *const ()) -> RawWaker {
    let (id, tx) = &*(data as *const (usize, Sender<usize>));
    let new = Box::into_raw(Box::new((*id, tx.clone()))) as *const ();
    RawWaker::new(new, &WAKER_VTABLE)
}

unsafe fn wake_raw(data: *const ()) {
    let (id, tx) = &*(data as *const (usize, Sender<usize>));
    let _ = tx.send(*id);
}

unsafe fn wake_by_ref_raw(data: *const ()) {
    let (id, tx) = &*(data as *const (usize, Sender<usize>));
    let _ = tx.send(*id);
}

unsafe fn drop_raw(data: *const ()) {
    drop(Box::from_raw(data as *mut (usize, Sender<usize>)));
}

// ---------- 任务存储 ----------
struct Inner {
    tx: Sender<usize>,
    tasks: RefCell<HashMap<usize, Rc<RefCell<Option<BoxFuture>>>>>,
    next_id: Cell<usize>,
}

impl Inner {
    fn spawn<F: Future<Output = ()> + 'static>(&self, fut: F) -> usize {
        let id = self.next_id.get();
        self.next_id.set(id + 1);
        self.tasks
            .borrow_mut()
            .insert(id, Rc::new(RefCell::new(Some(Box::pin(fut)))));
        let _ = self.tx.send(id);
        id
    }
}

// ---------- 运行时 ----------
pub struct Runtime {
    inner: Rc<Inner>,
    rx: Receiver<usize>,
}

// 可复制的句柄, 方便在任务内部再 spawn 新任务
#[derive(Clone)]
pub struct Handle {
    inner: Rc<Inner>,
}

impl Handle {
    pub fn spawn<F: Future<Output = ()> + 'static>(&self, fut: F) -> usize {
        self.inner.spawn(fut)
    }
}

impl Runtime {
    pub fn new() -> Self {
        let (tx, rx) = channel();
        let inner = Rc::new(Inner {
            tx,
            tasks: RefCell::new(HashMap::new()),
            next_id: Cell::new(0),
        });
        Runtime { inner, rx }
    }

    pub fn handle(&self) -> Handle {
        Handle {
            inner: self.inner.clone(),
        }
    }

    pub fn spawn<F: Future<Output = ()> + 'static>(&self, fut: F) -> usize {
        self.inner.spawn(fut)
    }

    /// 运行一个 future 直到完成, 并返回它的结果
    pub fn block_on<F: Future + 'static>(&self, fut: F) -> F::Output {
        let result: Rc<RefCell<Option<F::Output>>> = Rc::new(RefCell::new(None));
        let result2 = result.clone();
        self.spawn(async move {
            let out = fut.await;
            *result2.borrow_mut() = Some(out);
        });
        self.run();
        let x = result.borrow_mut().take().unwrap();
        x
    }

    /// 事件循环: 从 channel 取任务 id, 然后 poll 它
    fn run(&self) {
        loop {
            if self.inner.tasks.borrow().is_empty() {
                break;
            }
            let Ok(id) = self.rx.recv() else { break };
            self.poll(id);
        }
    }

    fn poll(&self, id: usize) {
        let task = match self.inner.tasks.borrow().get(&id) {
            Some(t) => t.clone(),
            None => return,
        };
        let mut slot = task.borrow_mut();
        let Some(mut fut) = slot.take() else { return };

        let waker = make_waker(id, self.inner.tx.clone());
        let mut cx = Context::from_waker(&waker);
        match fut.as_mut().poll(&mut cx) {
            Poll::Ready(()) => {
                self.inner.tasks.borrow_mut().remove(&id);
            }
            Poll::Pending => {
                *slot = Some(fut);
            }
        }
    }
}

// ---------- 定时器 ----------
// 极简做法: 每睡一次就开一个线程, 睡醒后唤醒任务。
// 生产环境会用 epoll / IOCP / timer wheel, 这里只图最少代码。
pub struct Sleep {
    deadline: Option<Instant>,
    spawned: bool,
    dur: Duration,
}

impl Future for Sleep {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        if self.deadline.is_none() {
            self.deadline = Some(Instant::now() + self.dur);
        }
        // 到期就返回 Ready, 否则挂起等线程来唤醒
        if Instant::now() >= self.deadline.unwrap() {
            return Poll::Ready(());
        }
        if !self.spawned {
            self.spawned = true;
            let waker = cx.waker().clone();
            let dur = self.dur;
            thread::spawn(move || {
                thread::sleep(dur);
                waker.wake();
            });
        }
        Poll::Pending
    }
}

pub fn sleep(dur: Duration) -> Sleep {
    Sleep {
        deadline: None,
        spawned: false,
        dur,
    }
}