如何用unsync::OnceCell/Lazy实现非Sync类型的懒加载全局实例？

问题描述 #

我正在研究once_cell的全局/静态实例懒初始化功能，文档示例主要针对Sync场景（使用sync::OnceCell/sync::Lazy）。尝试为非Sync类型实现该功能时，直接替换为unsync::Lazy会触发编译错误。

模拟非Sync类型的测试代码：

use once_cell::unsync::Lazy;
use std::cell::Cell;
use std::marker::PhantomData;

// 非Sync类型示例
struct TypeNotSync {
    _marker: PhantomData<Cell<()>>,
}

static GLOBAL_DATA: Lazy<TypeNotSync> = Lazy::new(|| 
  // 暂时忽略实际初始化逻辑...
  unimplemented!()
);

编译器报错信息：

error[E0277]: `Cell<std::option::Option<fn() -> TypeNotSync>>` cannot be shared between threads safely
   --> src/resources.rs:75:21
    |
75  | static GLOBAL_DATA: Lazy<TypeNotSync> = Lazy::new(|| unimplemented!());
    |                     ^^^^^^^^^^^^^^^^^ `Cell<std::option::Option<fn() -> TypeNotSync>>` cannot be shared between threads safely
    |
    = help: within `once_cell::unsync::Lazy<TypeNotSync>`, the trait `Sync` is not implemented for `Cell<std::option::Option<fn() -> TypeNotSync>>`
    = note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock`
note: required because it appears within the type `Lazy<TypeNotSync>`
   --> /home/fabian/.cargo/registry/src/index.crates.io-6f17d22bba15001f/once_cell-1.18.0/src/lib.rs:716:16
    |
716 |     pub struct Lazy<T, F = fn() -> T> {
    |                ^^^^
    = note: shared static variables must have a type that implements `Sync`

直接使用unsync::OnceCell也会出现同样问题。unsync::OnceCell本身不要求T: Sync，但Rust对全局static变量有强制要求：共享静态变量的类型必须实现Sync，这才是报错的核心原因。函数内的局部Lazy变量可以正常编译，但无法满足全局实例的需求。

解决方案 #

全局static变量本质是跨线程共享的，必须保证线程安全。要为非Sync类型实现全局懒加载，需要用线程安全的同步原语（如Mutex或RwLock）包裹非Sync类型，再结合sync版本的OnceCell/Lazy完成懒初始化。

方案1：用sync::Lazy + Mutex #

use once_cell::sync::Lazy;
use std::cell::Cell;
use std::marker::PhantomData;
use std::sync::Mutex;

// 非Sync类型示例
struct TypeNotSync {
    _marker: PhantomData<Cell<()>>,
    value: u32,
}

static GLOBAL_DATA: Lazy<Mutex<TypeNotSync>> = Lazy::new(|| {
    Mutex::new(TypeNotSync {
        _marker: PhantomData,
        value: 0,
    })
});

// 使用示例
fn main() {
    let mut data = GLOBAL_DATA.lock().unwrap();
    data.value += 1;
    println!("Value: {}", data.value);
}

方案2：用sync::OnceCell + Mutex #

如果需要更显式的初始化控制，可以用OnceCell：

use once_cell::sync::OnceCell;
use std::cell::Cell;
use std::marker::PhantomData;
use std::sync::Mutex;

struct TypeNotSync {
    _marker: PhantomData<Cell<()>>,
    value: u32,
}

static GLOBAL_DATA: OnceCell<Mutex<TypeNotSync>> = OnceCell::new();

// 提供全局访问入口
fn get_global_data() -> &'static Mutex<TypeNotSync> {
    GLOBAL_DATA.get_or_init(|| {
        Mutex::new(TypeNotSync {
            _marker: PhantomData,
            value: 0,
        })
    })
}

fn main() {
    let mut data = get_global_data().lock().unwrap();
    data.value += 1;
    println!("Value: {}", data.value);
}

原理说明 #

• sync::Lazy/sync::OnceCell本身实现了Sync，满足全局static变量的类型要求；
• Mutex（或RwLock）作为线程安全容器，包裹非Sync类型后，确保多线程访问时的互斥性，符合Rust的线程安全规则；
• 懒初始化逻辑由sync版本的OnceCell/Lazy负责，保证实例只会被初始化一次。

如果你的场景是单线程独占使用全局实例，也可以考虑用thread_local!宏结合unsync::Lazy，但这会让实例仅在当前线程可见，不符合全局跨线程共享的需求：

use once_cell::unsync::Lazy;
use std::cell::Cell;
use std::marker::PhantomData;

struct TypeNotSync {
    _marker: PhantomData<Cell<()>>,
    value: u32,
}

thread_local! {
    static THREAD_LOCAL_DATA: Lazy<TypeNotSync> = Lazy::new(|| {
        TypeNotSync {
            _marker: PhantomData,
            value: 0,
        }
    });
}

// 使用示例
fn main() {
    THREAD_LOCAL_DATA.with(|data| {
        println!("Value: {}", data.value);
    });
}

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