如何正确使用Rust OnceLock的get_mut()方法？编译报错求解

问题说明 #

根据Rust文档，OnceLock::get_mut() 可返回内部值的可变引用，但以下代码无法编译，核心疑问如下：

• 代码遗漏了什么？
• get_mut()是否真的能获取可变引用？
• 如何正确使用get_mut()？

用户提供的代码：

use std::sync::OnceLock;
#[derive(Clone)]
struct System {
    comp: Vec<i32>,
}

static GLOB: OnceLock<System> = OnceLock::new();

impl System {
    fn new() -> Self {
        Self { comp: Vec::new() }
    }
}
fn modify(global: &mut System) {
    global.comp.push(42);
}

fn main() {
    let sys: Box<System> = Box::new(System::new());
    GLOB.get_or_init(|| *sys);
    let global: &mut System = GLOB.get_mut().unwrap();
    println!("global size is {}", global.comp.len());
    modify(global);
    println!("global size is {}", global.comp.len());
}

编译失败原因 #

编译错误的核心是：全局static绑定的OnceLock默认是不可变的，而get_mut()方法要求调用者必须是&mut OnceLock。

查看get_mut()的方法签名：

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

它需要接收一个可变的self引用，但全局static GLOB是不可变绑定，无法直接获取&mut OnceLock<System>来调用该方法。

正确使用方式 #

OnceLock::get_mut()确实能返回可变引用，但需满足调用前提。根据不同场景，有以下几种解决方案：

场景1：非全局局部变量 #

如果OnceLock是局部可变绑定，可直接调用get_mut()：

use std::sync::OnceLock;

#[derive(Clone)]
struct System {
    comp: Vec<i32>,
}

impl System {
    fn new() -> Self {
        Self { comp: Vec::new() }
    }
}

fn modify(global: &mut System) {
    global.comp.push(42);
}

fn main() {
    // 局部可变的OnceLock
    let mut glob = OnceLock::new();
    glob.get_or_init(System::new);
    
    let global = glob.get_mut().unwrap();
    println!("global size is {}", global.comp.len());
    modify(global);
    println!("global size is {}", global.comp.len());
}

场景2：单线程全局变量 #

单线程场景下，用RefCell包裹内部值，通过内部可变性实现可变访问：

use std::sync::OnceLock;
use std::cell::RefCell;

#[derive(Clone)]
struct System {
    comp: Vec<i32>,
}

static GLOB: OnceLock<RefCell<System>> = OnceLock::new();

impl System {
    fn new() -> Self {
        Self { comp: Vec::new() }
    }
}

fn modify(global: &mut System) {
    global.comp.push(42);
}

fn main() {
    GLOB.get_or_init(|| RefCell::new(System::new()));
    
    // 通过borrow_mut()获取可变引用
    let mut global = GLOB.get().unwrap().borrow_mut();
    println!("global size is {}", global.comp.len());
    modify(&mut global);
    println!("global size is {}", global.comp.len());
}

场景3：多线程全局变量 #

多线程场景下，用Mutex保证线程安全的可变访问：

use std::sync::{OnceLock, Mutex};

#[derive(Clone)]
struct System {
    comp: Vec<i32>,
}

static GLOB: OnceLock<Mutex<System>> = OnceLock::new();

impl System {
    fn new() -> Self {
        Self { comp: Vec::new() }
    }
}

fn modify(global: &mut System) {
    global.comp.push(42);
}

fn main() {
    GLOB.get_or_init(|| Mutex::new(System::new()));
    
    // 加锁获取可变引用，需处理锁可能的错误
    let mut global = GLOB.get().unwrap().lock().unwrap();
    println!("global size is {}", global.comp.len());
    modify(&mut global);
    println!("global size is {}", global.comp.len());
}

总结 #

OnceLock::get_mut()确实可以返回可变引用，但仅当你能获取到&mut OnceLock时才能调用。全局static绑定默认不可变，因此无法直接使用该方法。根据场景选择局部可变绑定、RefCell（单线程）或Mutex（多线程）即可解决问题。

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