如何在异步Rust中原地修改Vector元素？

我有一个基础结构体：

pub struct Course {
    pub id : i32
}

已经从数据库读取数据存入Vec<Course>，同时还有多个同类型集合（如Departments、Buildings等）需要执行大量IO密集型操作，包括插入数据库、读写文件、批量修改元素。

项目目前使用了async/await但均为阻塞式调用，没有生成异步任务，也从未使用过Arc、Mutex或Future相关组件。现在尝试用异步任务处理时遇到编译错误。

尝试的核心代码：

pub async fn async_test(courses: Arc<Mutex<Vec<Course>>>) {
    let mut handles = vec![];

    let mut courses = courses.clone().lock().await.clone();
    for course in courses.iter_mut() {
        let handle = task::spawn(async move {
            println!("SPAWNED TASK FOR COURSE: {}", course.id);
            do_something(course);
        });
        handles.push(handle);
    }
    join_all(handles).await;
}

pub async fn do_something(course: &mut Course) {
    course.id = 12345;
    for i in 1..10 {
        println!("{}", i);
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }
}

编译错误：

error[E0597]: `courses` does not live long enough
  --> src/lib.rs:31:19
   |
30 |     let mut courses = courses.clone().lock().await.clone();
   |         ----------- binding `courses` declared here
31 |     for course in courses.iter_mut() {
   |                   ^^^^^^^^^^^^^^^^^^
   |                   |
   |                   borrowed value does not live long enough
   |                   argument requires that `courses` is borrowed for `'static`
...
39 | }
   | - `courses` dropped here while still borrowed

错误根源 #

• tokio::task::spawn要求传入的Future必须拥有'static生命周期，因为异步任务可能在当前函数结束后仍在运行。但你从courses.iter_mut()拿到的&mut Course是借用自当前函数内的courses变量，该变量会在函数结束时销毁，无法满足'static要求。
• 代码中克隆整个Vec<Course>完全多余，既浪费内存，又导致修改的是副本，原数据不会被更新。

方案一：拆分元素，转移所有权 #

如果不需要在任务执行期间保留原Vec的整体访问权限，可以一次性取出所有元素，转移所有权给异步任务，修改完成后再统一写回：

use tokio::task;
use std::sync::{Arc, Mutex};
use futures::future::join_all;

pub struct Course {
    pub id: i32,
}

pub async fn async_test(courses: Arc<Mutex<Vec<Course>>>) {
    let mut handles = vec![];

    // 一次性取出所有元素，立即释放全局锁
    let mut courses_lock = courses.lock().await;
    let courses_iter = courses_lock.drain(..);
    
    for mut course in courses_iter {
        let handle = task::spawn(async move {
            println!("SPAWNED TASK FOR COURSE: {}", course.id);
            do_something(&mut course).await;
            course // 返回修改后的元素
        });
        handles.push(handle);
    }

    // 等待所有任务完成，收集修改后的元素并写回
    let modified_courses = join_all(handles).await;
    let mut courses_lock = courses.lock().await;
    for res in modified_courses {
        if let Ok(course) = res {
            courses_lock.push(course);
        }
    }
}

pub async fn do_something(course: &mut Course) {
    course.id = 12345;
    for i in 1..10 {
        println!("{}", i);
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }
}

方案二：为单个元素加锁 #

如果需要保留原Vec结构，且允许任务执行期间其他地方访问Vec（不修改同一元素），可以将每个Course用Arc<Mutex>包裹，让每个任务仅锁定单个元素，提升并发度：

use tokio::task;
use std::sync::{Arc, Mutex};
use futures::future::join_all;

pub struct Course {
    pub id: i32,
}

// 存储结构改为 Arc<Mutex<Vec<Arc<Mutex<Course>>>>>
pub async fn async_test(courses: Arc<Mutex<Vec<Arc<Mutex<Course>>>>>) {
    let mut handles = vec![];

    // 先克隆每个Course的Arc，立即释放全局锁
    let course_clones = courses.lock().await
        .iter()
        .map(Arc::clone)
        .collect::<Vec<_>>();
    
    for course in course_clones {
        let handle = task::spawn(async move {
            let mut course_lock = course.lock().await;
            println!("SPAWNED TASK FOR COURSE: {}", course_lock.id);
            do_something(&mut course_lock).await;
        });
        handles.push(handle);
    }

    join_all(handles).await;
}

pub async fn do_something(course: &mut Course) {
    course.id = 12345;
    for i in 1..10 {
        println!("{}", i);
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }
}

额外注意事项 #

• 异步场景下优先使用tokio::sync::Mutex而非标准库的std::sync::Mutex，前者不会阻塞整个线程池，更适配异步调度。
• 异步函数do_something必须通过.await调用，否则仅创建Future而不会执行逻辑。
• 避免不必要的克隆操作，原代码中克隆整个Vec完全是冗余行为。

内容的提问来源于stack exchange，提问作者Bahadır Aydın