PAYATHON 2026

Rust 中如何 drop 全局 static OnceCell 内的对象?

数据小陈

按当前的 static HOLDER: OnceCell<MyStruct> 定义和 g2() -> &'static MyStruct 接口,无法通过安全的所有权操作直接取出并 drop HOLDER 内的对象。可以让局部变量拥有对象,或者调整全局存储方式,使对象能够在受控访问下被取出。

为什么 _ms 会析构,HOLDER 内的对象不会?

_ms 拥有一个 MyStruct,正常离开作用域时会调用它的 Drop 实现。

_ins 的类型是 &'static MyStruct,它借用的是 HOLDER 中的对象。该对象由 HOLDER 持有,而 Rust 的 static 项在程序结束时不会自动调用析构函数,这与 Tokio runtime 是否退出无关。Rust Reference:static 的生命周期

执行 drop(_ins) 也不会析构 HOLDER 中的对象。std::mem::drop 接收传入值的所有权,而这里传入的只是一个共享引用。std::mem::drop 文档

优先让局部作用域持有 OnceCell

如果不需要通过全局变量访问对象,可以把 OnceCell 放在 main 中,再把引用传给需要它的函数。保留原来的 MyStruct、new 和 Drop 实现,将 HOLDER、g2 和 main 替换为:

use tokio::sync::OnceCell;

async fn g2(holder: &OnceCell<MyStruct>) -> &MyStruct {
    holder
        .get_or_init(|| async { MyStruct::new().unwrap() })
        .await
}

#[tokio::main]
async fn main() {
    println!("Hello, world!");

    let _ms = MyStruct {};
    let holder = OnceCell::new();

    {
        let _ins = g2(&holder).await;
        // Use _ins here.
    }

    drop(holder);
}

返回引用的生命周期受 holder 的借用约束。所有借用使用完后,drop(holder) 会销毁这个局部 OnceCell,其中已初始化的 MyStruct 也会析构。也可以省略这行,让 holder 在 main 正常结束时自动析构。

如果初始化不涉及异步操作,也不需要延迟初始化,可以直接由 main 持有 MyStruct::new()? 的结果,再向其他函数传递引用。

为什么不能直接调用 HOLDER.take()?

tokio::sync::OnceCell 提供了两个相关方法:

pub fn take(&mut self) -> Option<T>
pub fn into_inner(self) -> Option<T>

take() 需要独占的可变引用,into_inner() 需要消费整个 OnceCell。原代码中的不可变 static HOLDER 无法提供这两种访问方式。Tokio OnceCell 文档

如果使用局部的 let mut holder = OnceCell::new(),可以在借用结束后调用 drop(holder.take()),取出并析构对象,同时保留一个空的 OnceCell。

必须保留全局访问时,用 Mutex<Option>

如果需要全局延迟初始化,同时还要显式释放对象,可以让 OnceCell 保存 Mutex<Option<MyStruct>>:

  • OnceCell 负责初始化全局容器。
  • Mutex 协调对象的访问和移除。
  • Option 表示对象当前存在还是已经被移除。

保留原来的 MyStruct 实现,将全局变量及相关函数替换为:

use tokio::sync::{Mutex, OnceCell};

static HOLDER: OnceCell<Mutex<Option<MyStruct>>> = OnceCell::const_new();

async fn g2() -> &'static Mutex<Option<MyStruct>> {
    HOLDER
        .get_or_init(|| async {
            Mutex::new(Some(MyStruct::new().unwrap()))
        })
        .await
}

async fn shutdown() {
    if let Some(holder) = HOLDER.get() {
        let value = {
            let mut guard = holder.lock().await;
            guard.take()
        };

        // Drop the object after releasing the lock.
        drop(value);
    }
}

#[tokio::main]
async fn main() {
    {
        let guard = g2().await.lock().await;
        let _ins = guard.as_ref().expect("MyStruct has been removed");
        // Use _ins while guard is held.
    }

    // Stop and await all tasks using HOLDER before shutdown.
    shutdown().await;
}

这里的 guard.take() 调用的是 Option::take(),它会移出内部值,并将原位置设为 None。随后 drop(value) 会析构取出的 MyStruct;如果没有对象,就不会执行 MyStruct 的析构逻辑。Option::take 文档

全局 OnceCell 本身仍然存在,但它不再持有那个 MyStruct。

调整接口时要注意什么?

允许移除对象后,获取对象的接口不能继续返回裸的 &'static MyStruct。调用方需要持有锁的 guard,并且只能在 guard 有效期间借用内部对象;上面的 g2() 返回的是对容器的引用。

实际应用中,应先停止新的访问任务并等待现有任务结束,再调用 shutdown()。锁能协调当前访问,但不会替应用决定何时停止工作。调用 shutdown() 时,也不能仍持有同一个 Mutex 的 guard,否则它会一直等待该锁释放。Tokio Mutex 文档

在这个实现中,移除对象后再次调用 g2(),得到的仍是同一个已初始化的容器,其中保存 None,不会自动重新创建 MyStruct。如果需要支持重新初始化,应另行定义相应的状态和访问规则。

备注:内容仅供参考。