可变静态变量 static mut
核心概念
static mut 声明一个全局可变的静态变量。静态变量在程序的整个运行期间都存在('static 生命周期),存储在程序的数据段中。普通的 static 变量是不可变的,可以安全使用;但 static mut 是可变的,读取和写入都需要在 unsafe 块中进行。原因是全局可变状态天然存在数据竞争的风险——任何线程、任何时刻都可能访问它,Rust 编译器无法静态验证不会出现并发读写冲突。
从 Rust 2024 edition 开始,直接使用 static mut 被标记为不推荐(lint 警告),建议使用更安全的替代方案如 AtomicXxx、Mutex 或 OnceLock。
// 声明可变静态变量
static mut COUNTER: u32 = 0;
static mut CONFIG: &str = "default";
fn main() {
// 读取和写入都需要 unsafe
// SAFETY: main 是单线程的,没有并发访问
unsafe {
COUNTER += 1;
CONFIG = "production";
println!("计数: {}", COUNTER);
println!("配置: {}", CONFIG);
}
}static mut 的特性
static mut GLOBAL_DATA: Vec<i32> = Vec::new();
static mut INIT_FLAG: bool = false;
fn initialize() {
// SAFETY: 假设只在单线程中调用一次
unsafe {
if !INIT_FLAG {
GLOBAL_DATA.push(1);
GLOBAL_DATA.push(2);
GLOBAL_DATA.push(3);
INIT_FLAG = true;
println!("初始化完成: {:?}", GLOBAL_DATA);
} else {
println!("已经初始化过了");
}
}
}
fn read_data() {
// SAFETY: 假设在初始化之后调用,且无并发修改
unsafe {
println!("数据: {:?}", GLOBAL_DATA);
}
}
fn main() {
initialize();
initialize(); // 第二次不会重复初始化
read_data();
// static mut 的特性:
// 1. 整个程序生命周期有效
// 2. 全局可访问(任何函数都能访问)
// 3. 读写都需要 unsafe
// 4. 没有线程安全保证
// 5. 初始值必须是编译时常量
}| 特性 | static(不可变) | static mut(可变) |
|---|---|---|
| 生命周期 | 'static | 'static |
| 可变性 | 不可变 | 可变 |
| 访问 | 安全 | 需要 unsafe |
| 线程安全 | 是(不可变天然安全) | 否(需手动保证) |
| 初始化 | 编译时常量 | 编译时常量 |
| 推荐程度 | 可以使用 | 不推荐 |
多线程中的数据竞争风险
static mut SHARED_COUNT: u64 = 0;
fn main() {
// 多线程访问 static mut 存在数据竞争
// 以下代码是错误的示范
let mut handles = Vec::new();
for _ in 0..10 {
handles.push(std::thread::spawn(|| {
for _ in 0..1000 {
// SAFETY: 这里实际上不安全!
// 多个线程同时读写 SHARED_COUNT 是数据竞争(UB)
unsafe {
SHARED_COUNT += 1;
}
}
}));
}
for h in handles {
h.join().unwrap();
}
// SAFETY: 所有线程已结束
unsafe {
println!("最终计数: {} (预期: 10000)", SHARED_COUNT);
// 结果可能不是 10000,因为存在数据竞争
}
}安全替代方案
use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
use std::sync::{Mutex, OnceLock};
// === 替代方案1:原子类型 ===
// 适合简单的计数器、标志位
static ATOMIC_COUNTER: AtomicU64 = AtomicU64::new(0);
static INITIALIZED: AtomicBool = AtomicBool::new(false);
// === 替代方案2:Mutex ===
// 适合需要保护的复杂数据
static MUTEX_DATA: Mutex<Vec<String>> = Mutex::new(Vec::new());
// === 替代方案3:OnceLock(一次性初始化)===
// 适合配置、数据库连接等只初始化一次的数据
static CONFIG: OnceLock<String> = OnceLock::new();
fn main() {
// 原子计数器:线程安全,不需要 unsafe
println!("=== 原子类型 ===");
let mut handles = Vec::new();
for _ in 0..10 {
handles.push(std::thread::spawn(|| {
for _ in 0..1000 {
ATOMIC_COUNTER.fetch_add(1, Ordering::SeqCst);
}
}));
}
for h in handles {
h.join().unwrap();
}
println!("原子计数: {} (正确: 10000)", ATOMIC_COUNTER.load(Ordering::SeqCst));
// Mutex 保护的数据
println!("\n=== Mutex ===");
{
let mut data = MUTEX_DATA.lock().unwrap();
data.push("Hello".to_string());
data.push("World".to_string());
}
{
let data = MUTEX_DATA.lock().unwrap();
println!("Mutex 数据: {:?}", *data);
}
// OnceLock 一次性初始化
println!("\n=== OnceLock ===");
CONFIG.get_or_init(|| {
println!(" 初始化配置(只执行一次)");
"production".to_string()
});
CONFIG.get_or_init(|| {
println!(" 不会执行第二次");
"other".to_string()
});
println!("配置: {}", CONFIG.get().unwrap());
}| 替代方案 | 适用场景 | 线程安全 | 需要 unsafe |
|---|---|---|---|
AtomicXxx | 简单计数器、标志位 | 是 | 否 |
Mutex<T> | 复杂数据的读写保护 | 是 | 否 |
RwLock<T> | 读多写少的共享数据 | 是 | 否 |
OnceLock<T> | 一次性初始化的全局数据 | 是 | 否 |
thread_local! | 线程局部数据 | 是(各线程独立) | 否 |
static mut 仍然适用的场景
// 虽然不推荐,但 static mut 在某些特殊场景中仍有用武之地
// === 场景1:中断处理器(嵌入式/bare-metal)===
// 在没有标准库的嵌入式环境中,没有 Mutex、Atomic 可用
// static mut 可能是唯一的选择
// static mut INTERRUPT_COUNT: u32 = 0;
// === 场景2:FFI 回调中的状态 ===
// C 库的回调函数通常没有用户数据参数
// 只能通过全局变量传递状态
static mut FFI_CALLBACK_DATA: i32 = 0;
extern "C" fn callback() {
// SAFETY: 假设回调在单线程中调用
unsafe {
FFI_CALLBACK_DATA += 1;
}
}
// === 场景3:程序启动时的单线程初始化 ===
static mut EARLY_CONFIG: Option<String> = None;
fn early_init() {
// SAFETY: 在 main 之前或 main 开头调用,
// 此时只有一个线程
unsafe {
EARLY_CONFIG = Some("早期配置".to_string());
}
}
fn main() {
early_init();
// 调用 FFI 回调
callback();
callback();
callback();
// SAFETY: 单线程调用
unsafe {
println!("FFI 回调次数: {}", FFI_CALLBACK_DATA);
}
// 读取早期配置
// SAFETY: 初始化后只读
unsafe {
if let Some(ref config) = EARLY_CONFIG {
println!("早期配置: {}", config);
}
}
println!("\n在大多数情况下,请使用 Atomic/Mutex/OnceLock 替代 static mut");
}基本示例
对比 static mut 和安全替代方案的使用:
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::Mutex;
use std::thread;
// === 不安全版本:static mut ===
static mut UNSAFE_LOG: Vec<String> = Vec::new();
fn unsafe_log(msg: &str) {
// SAFETY: 调用者必须保证单线程访问
unsafe {
UNSAFE_LOG.push(msg.to_string());
}
}
fn print_unsafe_log() {
// SAFETY: 调用者必须保证没有并发修改
unsafe {
println!(" 不安全日志: {:?}", UNSAFE_LOG);
}
}
// === 安全版本:Mutex ===
static SAFE_LOG: Mutex<Vec<String>> = Mutex::new(Vec::new());
fn safe_log(msg: &str) {
// 不需要 unsafe
SAFE_LOG.lock().unwrap().push(msg.to_string());
}
fn print_safe_log() {
println!(" 安全日志: {:?}", *SAFE_LOG.lock().unwrap());
}
// === 安全计数器 ===
static REQUEST_COUNT: AtomicU32 = AtomicU32::new(0);
fn handle_request(id: u32) {
REQUEST_COUNT.fetch_add(1, Ordering::SeqCst);
safe_log(&format!("处理请求 #{}", id));
}
fn main() {
// 不安全版本(仅在单线程中安全)
println!("=== 不安全日志(单线程)===");
unsafe_log("启动");
unsafe_log("运行中");
print_unsafe_log();
// 安全版本(多线程安全)
println!("\n=== 安全日志(多线程)===");
let mut handles = Vec::new();
for i in 0..5 {
handles.push(thread::spawn(move || {
handle_request(i);
}));
}
for h in handles {
h.join().unwrap();
}
print_safe_log();
println!(" 总请求数: {}", REQUEST_COUNT.load(Ordering::SeqCst));
// 对比总结
println!("\n=== 对比 ===");
println!("static mut: 需要 unsafe,无线程安全保证");
println!("Mutex: 不需要 unsafe,线程安全");
println!("Atomic: 不需要 unsafe,线程安全,性能更好(简单类型)");
}常见问题
问题一:static mut 为什么需要 unsafe?
因为全局可变状态可以被任何代码在任何时刻访问,编译器无法验证不存在数据竞争。多个线程同时读写 static mut 是未定义行为,而编译器不能阻止你在多线程中使用它。
问题二:static mut 在 Rust 2024 中被废弃了吗?
没有完全废弃,但被标记为不推荐。编译器会发出 lint 警告,鼓励使用更安全的替代方案。在嵌入式等特殊场景中仍然可以使用。
问题三:static mut 的初始值可以是什么?
必须是编译时常量(const expression)。不能调用运行时函数来初始化。如果需要运行时初始化,用 OnceLock 或 lazy_static!。Vec::new() 和 String::new() 在 Rust 中是 const fn,所以可以作为初始值。
问题四:在单线程程序中 static mut 安全吗?
从数据竞争的角度是安全的(只有一个线程),但仍然有可能通过递归调用或回调产生别名冲突。编译器不会为你检查这些,所以仍然需要 unsafe 并需要谨慎。
适用场景
- 嵌入式/bare-metal:没有标准库的环境,无法使用 Mutex/Atomic
- FFI 回调:C 库回调需要通过全局状态传递数据
- 早期初始化:main 之前的单线程初始化阶段
- 遗留代码:移植 C 代码时的临时方案
注意事项
- 读写
static mut都需要 unsafe - 多线程并发访问
static mut是数据竞争(UB) - 优先使用
AtomicXxx、Mutex、OnceLock等安全替代方案 - 初始值必须是编译时常量
- Rust 2024 edition 对
static mut发出不推荐警告 - 即使单线程也要注意递归和回调导致的重入问题
总结
static mut 声明全局可变的静态变量,整个程序生命周期有效。由于全局可变状态存在数据竞争风险,读写都需要在 unsafe 块中进行。多线程并发访问 static mut 是未定义行为。Rust 2024 edition 将其标记为不推荐,鼓励使用安全替代方案:AtomicXxx 用于简单的计数器和标志位,Mutex<T> 用于复杂数据的线程安全访问,OnceLock<T> 用于一次性初始化的全局数据。static mut 仍然在嵌入式环境(无标准库)、FFI 回调和早期初始化等特殊场景中有用。使用时必须由程序员保证不会发生并发访问。