含Box化异步回调的结构体生命周期需满足'static的问题排查

简化后的示例代码 #

use std::{future::Future, pin::Pin, thread::JoinHandle, fmt::Debug};

use tokio::runtime::Runtime;

struct Callback<E> {
    f: Box<dyn Fn() -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>,
}

trait Provider {
    fn setup(&self) -> JoinHandle<()>;
}

enum Foo {
    A,
    B
}

trait IntoFoo {
    fn into_foo(&self) -> Foo;
}

impl<E: Debug + IntoFoo> Provider for Callback<E> {
    fn setup(&self) -> JoinHandle<()> {
        std::thread::spawn(move || {
            // Running async function sycnhronously within another thread.
            let rt = Runtime::new().unwrap();
            rt.block_on(handle(Box::new(move || (self.f)())))
              .expect("request loop failed")
          })
    }
}

async fn handle<E: Debug + IntoFoo + 'static>( callback_fn: Box<dyn Fn() -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>) -> Result<(), E> {
    perform(Box::new(move || (callback_fn)())).await
}

pub async fn perform<
  E: Debug + IntoFoo>(
  op: Box<dyn Fn() -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>,
) -> Result<(), E> {
    (op)().await
}

报错信息 #

error: lifetime may not live long enough
  --> src/indexer/callback.rs:41:41
   |
27 |   fn bootstrap(&self, input: StageReceiver) -> BootstrapResult {
   |                - let's call the lifetime of this reference `'1`
...
41 |         rt.block_on(handle_event(input, Box::new(move |ev: &Event| (self.f)(ev)), &retry_policy, utils))
   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cast requires that `'1` must outlive `'static`

需求说明 #

需要在结构体中封装异步回调并在多函数间传递，其中一个函数会在新线程中调用该回调，且回调需要支持多次调用（可能在handle的循环中）。此前尝试Box化异步回调方案未解决问题。

解决方案 #

核心问题分析 #

报错根源是：bootstrap函数中持有&self的短期引用（生命周期'1），但创建的闭包被传递给新线程后，线程要求捕获的变量必须满足'static生命周期——线程的存活时间可能超过当前函数的生命周期，编译器无法保证self能存活到线程结束。

具体修改方案 #

1. 转移Callback所有权到线程（优先方案）

如果Callback可以被转移所有权，直接修改Provider trait和实现，让线程拥有self的完整所有权，彻底消除生命周期依赖：

// 修改Provider trait的setup方法为获取self所有权
trait Provider {
    fn setup(self) -> JoinHandle<()>;
}

// 修改Callback的Provider实现
impl<E: Debug + IntoFoo + 'static> Provider for Callback<E> {
    fn setup(self) -> JoinHandle<()> {
        std::thread::spawn(move || {
            let rt = Runtime::new().unwrap();
            rt.block_on(handle(Box::new(move || (self.f)())))
              .expect("request loop failed")
        })
    }
}

此方案下，self的所有权被转移到线程中，既满足'static要求，又能保证回调可以被多次调用。

2. 用Arc共享回调所有权（无法转移所有权时使用）

如果Callback不能被转移所有权，使用Arc来共享闭包的所有权，让线程持有Arc克隆：

use std::sync::Arc;

// 修改Callback结构体，用Arc包裹闭包
struct Callback<E> {
    f: Arc<dyn Fn() -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>,
}

// 修改Provider实现
impl<E: Debug + IntoFoo + 'static> Provider for Callback<E> {
    fn setup(&self) -> JoinHandle<()> {
        let f_clone = Arc::clone(&self.f);
        std::thread::spawn(move || {
            let rt = Runtime::new().unwrap();
            rt.block_on(handle(Box::new(move || f_clone())))
              .expect("request loop failed")
        })
    }
}

线程持有Arc克隆后，和原Callback共享闭包所有权，既满足生命周期要求，又支持回调多次调用。

3. 适配带参数的回调（如实际代码中的&Event）

针对实际报错中接收&Event参数的回调，需确保参数生命周期不绑定外部短期引用：

use std::sync::Arc;

// 调整Callback的闭包类型，支持接收&Event参数
struct Callback<E> {
    f: Arc<dyn Fn(&Event) -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>,
}

// 适配handle和perform函数的参数
async fn handle<E: Debug + IntoFoo + 'static>(
    callback_fn: Arc<dyn Fn(&Event) -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>,
    event: &Event,
) -> Result<(), E> {
    perform(callback_fn, event).await
}

pub async fn perform<E: Debug + IntoFoo>(
    op: Arc<dyn Fn(&Event) -> Pin<Box<dyn Future<Output = Result<(), E>> + Send + Sync>> + Send + Sync>,
    event: &Event,
) -> Result<(), E> {
    (op)(event).await
}

如果Event是外部短期引用，需将其克隆后传递到线程中，避免生命周期不匹配。

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