Spawns

Rust的线程上下文任务生成器，简化异步运行时无关的编码。

动机

目前，Rust没有标准的异步运行时。这让我们陷入两难境地，需要选择一个，并且创建运行时无关的库相当困难。我们面临的最大的挑战是如何生成任务？

spawns-core 为 Rust std 和异步运行时提出了线程上下文任务生成器。一旦实现，我们就能以运行时无关的方式生成任务。结合其他运行时无关的 io、定时器、通道等工具包，我们可以轻松编写运行时无关的代码。

异步运行时的API

/// Thin wrapper around task to accommodate possible new members.
#[non_exhaustive]
pub struct Task {
    pub id: Id,
    pub name: Name,
    pub future: Box<dyn Future<Output = ()> + Send + 'static>,
}

/// Trait to spawn task.
pub trait Spawn {
    fn spawn(&self, task: Task);
}

/// Scope where tasks are [spawn]ed through given [Spawn].
pub struct SpawnScope<'a> {}

/// Enters a scope where new tasks will be [spawn]ed through given [Spawn].
pub fn enter(spawner: &dyn Spawn) -> SpawnScope<'_>;

异步运行时必须完成两个步骤以适应其他运行时无关的API。

1. 实现 Spawn 以生成异步任务。
2. 在所有执行器线程中调用 enter。

客户端的API

impl<T> JoinHandle<T> {
    /// Gets id of the associated task.
    pub fn id(&self) -> Id {}

    /// Cancels associated task with this handle.
    ///
    /// Cancellation is inherently concurrent with task execution. Currently, there is no guarantee
    /// about promptness, the task could even run to complete normally after cancellation.
    pub fn cancel(&self) { }

    /// Attaches to associated task to gain cancel on [Drop] permission.
    pub fn attach(self) -> TaskHandle<T> { }
}

impl<T> Future for JoinHandle<T> {
    type Output = Result<T, JoinError>;
}

/// Spawns a new task.
///
/// # Panics
/// 1. Panic if no spawner.
/// 2. Panic if [Spawn::spawn] panic.
pub fn spawn<T, F>(f: F) -> JoinHandle<T>
where
    F: Future<Output = T> + Send + 'static,
    T: Send + 'static;

该API可以生成、连接和取消任务，就像 tokio、smol 和 async-std 一样。

关注点

1. 装箱？是的，它需要 GlobalAlloc。
2. 甚至将入口未来装箱？不，但 try_id() 将返回 None。我想我们可以提供一些包装函数。
3. no_std？不，它目前需要 thread_local!。一旦稳定，我们可以将其移动到 #[thread_local]。
4. spawn_local 用于 !Send future？不，至少现在还不是。我只看到 async-global-executor 能够自由地 spawn_local。我个人认为，这是 Rust 的责任，不要将拥有 !Send 的 future 视为 !Send。这样，我们创建 !Send future 的机会就很小了。对于首先捕获 !Send 并存储线程局部 !Send 的 future，它们需要当前线程的 executor。

兼容性

包 spawns-core 使用 linkme 来检测外部包中可用的异步运行时。包 spawns-compat 提供了 tokio、smol 和 async-global-executor 功能来检测 spawns-core 的异步运行时。smol 和 async-global-executor 不能共存，因为它们没有 tokio::runtime::Handle::try_current() 这样的方法来检测线程上下文感知 executor。

集成

包 spawns-executor 提供了与当前线程 executor 和多线程 executor 一起使用的完整功能的 block_on。

示例

请参阅 示例。这里列出了一个用于演示的最小运行时不敏感的回显服务器。

use async_net::*;
use futures_lite::io;

pub async fn echo_server(port: u16) {
    let listener = TcpListener::bind(("127.0.0.1", port)).await.unwrap();
    println!("Listen on port: {}", listener.local_addr().unwrap().port());
    let mut echos = vec![];
    let mut id_counter = 0;
    loop {
        let (stream, remote_addr) = listener.accept().await.unwrap();
        id_counter += 1;
        let id = id_counter;
        let handle = spawns::spawn(async move {
            eprintln!("{:010}[{}]: serving", id, remote_addr);
            let (reader, writer) = io::split(stream);
            match io::copy(reader, writer).await {
                Ok(_) => eprintln!("{:010}[{}]: closed", id, remote_addr),
                Err(err) => eprintln!("{:010}[{}]: {:?}", id, remote_addr, err),
            }
        })
        .attach();
        echos.push(handle);
    }
}

要使其正常工作，您只需要设置线程上下文任务生成器。

许可证

Apache-2.0