Tokio中通过通道传递闭包时出现‘生命周期不足’错误

问题重现 #

以下是最小复现代码：

use tokio; // 1.32.0

#[tokio::main]
async fn main() {
    
    let (send, recv) = tokio::sync::oneshot::channel();
    
    let val: u32 = 0;
    
    let func = move |foo: &u32| async move { val + foo };

    let _ = send.send(func);
    
    let fut = async move {
    
        let f = recv.await.expect("receiver should not fail");

        let foo: u32 = 1;
        let res = f(&foo).await;
        println!("Result: {}", res);
        assert_eq!(res, 1);
    };

    tokio::spawn(fut).await.expect("thread should succeed");

}

编译时触发的错误：

Compiling playground v0.0.1 (/playground)
error: lifetime may not live long enough
  --> src/main.rs:10:33
   |
10 |     let func = move |foo: &u32| async move { val + foo };
   |                           -   - ^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
   |                           |   |
   |                           |   return type of closure `[async block@src/main.rs:10:33: 10:57]` contains a lifetime `'2`
   |                           let's call the lifetime of this reference `'1`

error: could not compile `playground` (bin "playground") due to previous error

错误原因 #

1. 生命周期绑定问题：闭包接收&u32引用后，返回的async move块捕获了该引用。Rust会推断出：返回的Future生命周期必须与输入引用foo的生命周期绑定，即foo必须在Future被await的全程保持有效。
2. 跨线程的生命周期不确定性：闭包通过oneshot通道被发送到另一个线程后，调用时机是在接收线程的异步块内。编译器无法保证此时传入的foo（接收线程栈上的局部变量）的生命周期，能覆盖Future从创建到await完成的整个周期，因此触发生命周期不匹配错误。
3. 'static约束隐含要求：tokio::spawn要求传入的Future必须是'static（不持有任何非静态生命周期的引用）。虽然闭包因move捕获val满足'static，但它返回的Future持有对临时引用foo的依赖，与'static约束冲突。

解决方案 #

方案1：传递值而非引用（最简单） #

将闭包参数从引用改为值类型，让返回的Future无需持有任何引用，直接消除生命周期问题：

use tokio; // 1.32.0

#[tokio::main]
async fn main() {
    
    let (send, recv) = tokio::sync::oneshot::channel();
    
    let val: u32 = 0;
    
    // 闭包接收u32值而非引用
    let func = move |foo: u32| async move { val + foo };

    let _ = send.send(func);
    
    let fut = async move {
    
        let f = recv.await.expect("receiver should not fail");

        let foo: u32 = 1;
        // 直接传递值
        let res = f(foo).await;
        println!("Result: {}", res);
        assert_eq!(res, 1);
    };

    tokio::spawn(fut).await.expect("thread should succeed");

}

方案2：使用Arc包装共享值（必须用引用时） #

如果必须通过引用传递数据，用Arc（原子引用计数指针）将值包装为'static生命周期的共享对象，闭包接收Arc<u32>并在异步块中使用：

use tokio; // 1.32.0
use std::sync::Arc;

#[tokio::main]
async fn main() {
    
    let (send, recv) = tokio::sync::oneshot::channel();
    
    let val: u32 = 0;
    
    // 闭包接收Arc<u32>
    let func = move |foo: Arc<u32>| async move { val + *foo };

    let _ = send.send(func);
    
    let fut = async move {
    
        let f = recv.await.expect("receiver should not fail");

        let foo = Arc::new(1u32);
        // 传递Arc（自动clone）
        let res = f(foo).await;
        println!("Result: {}", res);
        assert_eq!(res, 1);
    };

    tokio::spawn(fut).await.expect("thread should succeed");

}

内容的提问来源于stack exchange，提问作者sak