在async move块中使用&mut self引发生命周期错误的解决方案

问题描述 #

定义了一个WriterJob结构体用于启动长期任务并提供状态查询API，代码如下：

pub(crate) struct WriterJob {
    ...,
    status: Status,
}

impl WriterJob {
    async fn writer_job_impl(&mut self, rx: Receiver<WriteCommand>) {
       // 任务实现细节，需要可变的self来更新任务状态
       // 示例：
       // self.status = Status::Ready;
    }

    pub(crate) fn status(&self) -> Status {
       self.status
    }

    pub(crate) fn spawn_writer_job(&mut self) -> Sender<WriteCommand> {
        let (tx, rx) = mpsc::channel(10);

        let handle = tokio::spawn(async move {
            self.writer_job_impl(rx).await;
        });

        self.status = Status::Spawned;

        tx
    }
}

编译时触发如下错误：

error[E0521]: borrowed data escapes outside of associated function
  --> src/io/buffered_write.rs:92:22
   |
89 |       pub(crate) fn spawn_writer_job(&mut self) -> Sender<WriteCommand> {
   |                                      ---------
   |                                      |
   |                                      `self` is a reference that is only valid in the associated function body
   |                                      let's call the lifetime of this reference `'1`
...
92 |           let handle = tokio::spawn(async move {
   |  ______________________^
93 | |             self.writer_job_impl(rx).await;
94 | |         });
   | |          ^
   | |          |
   | |__________`self` escapes the associated function body here
   |            argument requires that `'1` must outlive `'static`

问题核心：tokio::spawn要求异步任务必须拥有'static生命周期，即不能持有外部的临时借用。将&mut self传入任务后，编译器无法保证self的生命周期覆盖任务全程，因此报错。

解决方案 #

方案1：转移结构体所有权到任务（推荐独占场景） #

如果WriterJob仅由该异步任务独占使用，可以将整个结构体的所有权转移到任务中，同时把状态字段用Arc<AtomicU8>包装，方便外部无锁查询状态：

use std::sync::Arc;
use tokio::sync::mpsc;
use tokio::sync::atomic::AtomicU8;

#[derive(Clone, Copy)]
pub(crate) enum Status {
    Idle,
    Spawned,
    Ready,
    // 其他自定义状态
}

// 实现Status与u8的互转，适配原子类型存储
impl From<u8> for Status {
    fn from(val: u8) -> Self {
        match val {
            0 => Status::Idle,
            1 => Status::Spawned,
            2 => Status::Ready,
            _ => Status::Idle,
        }
    }
}

impl From<Status> for u8 {
    fn from(status: Status) -> Self {
        match status {
            Status::Idle => 0,
            Status::Spawned => 1,
            Status::Ready => 2,
        }
    }
}

pub(crate) struct WriterJob {
    // 其他业务字段
    status: Arc<AtomicU8>,
}

impl WriterJob {
    async fn writer_job_impl(mut self, rx: mpsc::Receiver<WriteCommand>) {
        // 直接修改状态，无需借用
        self.status.store(Status::Ready.into(), std::sync::atomic::Ordering::SeqCst);
        // 任务核心逻辑...
    }

    pub(crate) fn status(&self) -> Status {
        self.status.load(std::sync::atomic::Ordering::SeqCst).into()
    }

    pub(crate) fn spawn_writer_job(self) -> mpsc::Sender<WriteCommand> {
        let (tx, rx) = mpsc::channel(10);
        let status_clone = self.status.clone();

        tokio::spawn(async move {
            self.writer_job_impl(rx).await;
        });

        // 更新任务启动状态
        status_clone.store(Status::Spawned.into(), std::sync::atomic::Ordering::SeqCst);

        tx
    }
}

该方案无锁开销，结构简洁，适合任务独占结构体的场景。

方案2：用Arc共享结构体所有权（适合多场景共享） #

如果WriterJob需要被多个线程或任务共享，可以将整个结构体包裹在Arc<Mutex>中，让任务持有共享所有权：

use std::sync::Arc;
use tokio::sync::{mpsc, Mutex};

pub(crate) enum Status {
    Idle,
    Spawned,
    Ready,
    // 其他自定义状态
}

pub(crate) struct WriterJob {
    // 其他业务字段
    status: Status,
}

impl WriterJob {
    async fn writer_job_impl(&mut self, rx: mpsc::Receiver<WriteCommand>) {
        self.status = Status::Ready;
        // 任务核心逻辑...
    }

    pub(crate) fn status(&self) -> Status {
        self.status.clone() // Status为Copy类型时可省略clone
    }

    pub(crate) fn spawn_writer_job(self: Arc<Mutex<Self>>) -> mpsc::Sender<WriteCommand> {
        let (tx, rx) = mpsc::channel(10);
        let this = self.clone();

        tokio::spawn(async move {
            let mut locked_self = this.lock().await;
            locked_self.writer_job_impl(rx).await;
        });

        // 更新启动状态
        let mut locked_self = self.lock().await;
        locked_self.status = Status::Spawned;

        tx
    }
}

后续添加新的可变字段时，无需额外修改同步逻辑，只需在锁定后操作即可，扩展性较好。

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