Rust中Tokio Cron调度任务报错：inferred to be a `FnMut` closure

问题背景 #

遍历向量向Tokio Cron调度器添加异步任务时，触发captured variable cannot escape FnMut closure body错误，尝试克隆变量、使用ARC均未解决。

代码示例 #

主逻辑代码：

for data in settings.data {
        sched.add(
            tokio_cron_scheduler::Job::new_async(
                data.clone().schedule.as_str(),
                move |_, _| Box::pin(async {
                    println!("{}", data.name);
                }),
            ).unwrap()).await.unwrap();
    }

结构体定义：

#[derive(Deserialize, Debug)]
pub struct Settings {
    pub data: Vec<Data>
}

#[derive(Deserialize, Debug, Clone)]
pub struct Data {
    pub name: String,
    pub schedule: String
}

错误信息 #

error: captured variable cannot escape `FnMut` closure body
  --> src\main.rs:30:29
   |
22 |       for data in settings.data {
   |           ---- variable defined here
...
30 |                   move |_, _| Box::pin(async {
   |  ___________________________-_^
   | |                           |
   | |                           inferred to be a `FnMut` closure
31 | |                     log::info!("starting job for task: {}", &data.name);
   | |                                                              ---- variable captured here
32 | |                 }),
   | |__________________^ returns a reference to a captured variable which escapes the closure body
   |
   = note: `FnMut` closures only have access to their captured variables while they are executing...
   = note: ...therefore, they cannot allow references to captured variables to escape

问题原因 #

Job::new_async要求传入的闭包为FnMut类型，这类闭包仅能在执行期间访问捕获的变量，不允许变量引用逃逸到闭包外部。而异步块会在闭包执行结束后才可能运行，你在异步块中引用了data的字段，导致引用生命周期超出闭包执行周期，触发编译器错误。

之前的克隆操作仅针对schedule字段，并未解决data整体的所有权与生命周期问题。

解决方案 #

核心是让异步块拥有变量的完整所有权，而非引用。在循环内先完整克隆Data实例，再将克隆体移动到闭包和异步块中：

修改后的代码：

for data in settings.data {
    // 提前克隆整个Data实例，让异步块可以获取所有权
    let job_data = data.clone();
    sched.add(
        tokio_cron_scheduler::Job::new_async(
            data.schedule.as_str(),
            move |_, _| Box::pin(async {
                println!("{}", job_data.name);
            }),
        ).unwrap()
    ).await.unwrap();
}

或者拆分克隆，让代码更清晰：

for data in settings.data {
    let job_name = data.name.clone();
    let schedule = data.schedule;
    sched.add(
        tokio_cron_scheduler::Job::new_async(
            &schedule,
            move |_, _| Box::pin(async {
                println!("{}", job_name);
            }),
        ).unwrap()
    ).await.unwrap();
}

原理说明 #

通过克隆获取Data实例（或其字段）的所有权后，move闭包会将克隆体的所有权转移到自身内部，异步块再获取该所有权。这样异步块的生命周期不再依赖原data或闭包的执行周期，编译器可以确认引用的有效性，从而消除错误。

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