可变静态变量 static mut ​

核心概念 ​

static mut 声明一个全局可变的静态变量。静态变量在程序的整个运行期间都存在('static 生命周期),存储在程序的数据段中。普通的 static 变量是不可变的,可以安全使用;但 static mut 是可变的,读取和写入都需要在 unsafe 块中进行。原因是全局可变状态天然存在数据竞争的风险——任何线程、任何时刻都可能访问它,Rust 编译器无法静态验证不会出现并发读写冲突。

从 Rust 2024 edition 开始,直接使用 static mut 被标记为不推荐(lint 警告),建议使用更安全的替代方案如 AtomicXxx、Mutex 或 OnceLock。

rust
// 声明可变静态变量
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 的特性 ​

rust
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
线程安全是(不可变天然安全)否(需手动保证)
初始化编译时常量编译时常量
推荐程度可以使用不推荐

多线程中的数据竞争风险 ​

rust
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,因为存在数据竞争
    }
}

安全替代方案 ​

rust
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 仍然适用的场景 ​

rust
// 虽然不推荐,但 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 和安全替代方案的使用:

rust
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 回调和早期初始化等特殊场景中有用。使用时必须由程序员保证不会发生并发访问。