Rust全局应用状态管理：替代static mut与unsafe的方案

背景 #

学习Rust期间，项目需要设置可全应用访问的全局APP_STATE及其他全局变量，且必须设为全局，避免在所有函数和trait中传参。

问题现状 #

当前使用可变静态变量实现全局状态，访问时必须包裹unsafe块，且应用涉及并发、性能要求极高（图形应用），目前unsafe包裹了整个主循环，存在线程安全隐患。代码示例：

pub struct AppState {
    running: bool,
    suspended: bool
}

static mut APP_STATE = AppState {running: true, suspended:false}

访问示例：

pub unsafe fn create_app {
    APP_STATE.running = true;
    APP_STATE.suspended = false;
}

unsafe fn confirm_app_state_valid() {
    if APP_STATE.running == APP_STATE.suspended { // 布尔值相等即XNOR（逻辑双条件）运算符
        fatal("Fatal! App was both running and suspended at same time. Could not resolve. Crashed")
    };
}

需求 #

1. 移除或减少unsafe的使用，避免数据竞争；
2. 无需将状态作为参数在代码中到处传递。

解决方案 #

针对你的场景，推荐两种线程安全且高性能的实现方案：

方案一：原子类型（适合简单状态、极致性能） #

利用Rust标准库的原子类型（AtomicBool）实现无锁的线程安全访问，性能极高，完全不需要unsafe。

use std::sync::atomic::{AtomicBool, Ordering};
use lazy_static::lazy_static;

pub struct AppState {
    running: AtomicBool,
    suspended: AtomicBool,
}

// 线程安全的全局实例初始化
lazy_static! {
    pub static ref APP_STATE: AppState = AppState {
        running: AtomicBool::new(true),
        suspended: AtomicBool::new(false),
    };
}

pub fn create_app() {
    // 内存顺序选择Relaxed，适合无严格同步需求的图形应用场景，性能最优
    APP_STATE.running.store(true, Ordering::Relaxed);
    APP_STATE.suspended.store(false, Ordering::Relaxed);
}

fn confirm_app_state_valid() {
    let running = APP_STATE.running.load(Ordering::Relaxed);
    let suspended = APP_STATE.suspended.load(Ordering::Relaxed);
    
    if running == suspended {
        fatal("Fatal! App was both running and suspended at same time. Could not resolve. Crashed")
    }
}

说明：

• Ordering::Relaxed是性能最高的内存顺序，若你的场景不需要跨线程的强同步保证，完全可以使用；若有严格的内存一致性需求，可替换为Ordering::Acquire/Ordering::Release或Ordering::SeqCst。
• 原子类型支持直接的读写操作，无锁开销，完美适配图形应用的高性能要求。

方案二：RwLock（适合复杂状态结构） #

若未来AppState需要扩展为包含非原子类型的复杂结构，可使用RwLock结合lazy_static实现线程安全的全局状态，读操作支持并发，写操作独占，性能优于Mutex。

use std::sync::RwLock;
use lazy_static::lazy_static;

pub struct AppState {
    running: bool,
    suspended: bool,
    // 可扩展其他字段
}

// 线程安全的全局实例初始化
lazy_static! {
    pub static ref APP_STATE: RwLock<AppState> = RwLock::new(AppState {
        running: true,
        suspended: false,
    });
}

pub fn create_app() {
    // 获取写锁，独占访问状态
    let mut state = APP_STATE.write().expect("AppState lock poisoned");
    state.running = true;
    state.suspended = false;
}

fn confirm_app_state_valid() {
    // 获取读锁，支持多线程并发读取
    let state = APP_STATE.read().expect("AppState lock poisoned");
    if state.running == state.suspended {
        fatal("Fatal! App was both running and suspended at same time. Could not resolve. Crashed")
    }
}

说明：

• RwLock的读操作是并发安全的，多个线程可同时读取状态，适合读多写少的场景；
• 代码中使用expect处理锁中毒（PoisonError），实际项目中可根据需求替换为更严谨的错误处理逻辑；
• 完全不需要unsafe，编译期即可保证线程安全。

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