Rust中Future工厂方法编译报错：`'1`必须存活时间长于`'2`

我需要在异步上下文环境中重复执行用户提供的函数，因此尝试用非异步闭包生成可等待的Future，写出了以下最小复现代码：

use std::sync::{Arc, AtomicU64};
use std::sync::atomic::Ordering;

let counter = Arc::new(AtomicU64::new(0));
let counter_closure = counter.clone();
let future_producer = move || async {
    counter_closure.fetch_add(1, Ordering::SeqCst);
};

但编译时出现了如下错误：

562 |           let future_producer = move || async {
    |  _______________________________-------_^
    | |                               |     |
    | |                               |     return type of closure `impl Future<Output = ()>` contains a lifetime `'2`
    | |                               lifetime `'1` represents this closure's body
563 | |             counter_closure.fetch_add(1, Ordering::SeqCst);
564 | |         };
    | |_________^ returning this value requires that `'1` must outlive `'2`

问题原因 #

这个错误的核心是：异步块默认会借用闭包捕获的变量counter_closure，导致返回的Future生命周期依赖于闭包的生命周期（'1）。但闭包是被调用后就会销毁的，Rust的生命周期检查不允许Future持有一个已经失效的借用，因此要求'1必须长于'2，这在逻辑上无法满足。

解决方法 #

让异步块拥有捕获变量的所有权，而不是借用。可以通过两种方式实现：

方法1：在闭包内部clone Arc并移动到异步块

use std::sync::{Arc, AtomicU64};
use std::sync::atomic::Ordering;

fn main() {
    let counter = Arc::new(AtomicU64::new(0));
    let future_producer = move || {
        let counter_clone = counter.clone();
        async move {
            counter_clone.fetch_add(1, Ordering::SeqCst);
        }
    };
}

方法2：直接在async move块中clone Arc

use std::sync::{Arc, AtomicU64};
use std::sync::atomic::Ordering;

fn main() {
    let counter = Arc::new(AtomicU64::new(0));
    let future_producer = move || async move {
        counter.clone().fetch_add(1, Ordering::SeqCst);
    };
}

原理说明 #

• 使用async move关键字后，异步块会获取捕获变量的所有权，而不是默认的借用。
• 因为Arc是线程安全的引用计数类型，每次clone都会生成一个新的引用，不会影响原变量的生命周期。这样每个生成的Future都拥有独立的Arc引用，生命周期不再依赖于外部闭包，自然就能通过编译。

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