Rust原子枚举宏库portable_atomic_enum_macros的使用：跨平台安全的枚举原子操作与宏扩展

安装

在项目目录中运行以下Cargo命令：

cargo add portable_atomic_enum_macros

或者在Cargo.toml中添加以下行：

portable_atomic_enum_macros = "0.2.1"

使用示例

portable_atomic_enum_macros库提供了一种安全、跨平台的方式来对枚举类型进行原子操作。以下是一个完整的使用示例：

use portable_atomic_enum_macros::atomic_enum;
use std::sync::atomic::Ordering;

// 定义一个枚举类型并使用atomic_enum宏标记
#[atomic_enum]
#[derive(Debug, PartialEq, Eq)]
enum State {
    Idle,
    Running,
    Stopped,
}

fn main() {
    // 创建原子枚举实例
    let atomic_state = AtomicState::new(State::Idle);
    
    // 读取当前状态
    let current = atomic_state.load(Ordering::SeqCst);
    println!("Current state: {:?}", current);
    
    // 比较并交换操作
    let previous = atomic_state.compare_and_swap(
        State::Idle,
        State::Running,
        Ordering::SeqCst
    );
    println!("Previous state: {:?}", previous);
    
    // 存储新状态
    atomic_state.store(State::Stopped, Ordering::SeqCst);
    
    // 获取并设置新状态
    let old = atomic_state.swap(State::Idle, Ordering::SeqCst);
    println!("Old state: {:?}", old);
    
    // 检查当前状态
    let is_running = atomic_state.compare_exchange(
        State::Idle,
        State::Running,
        Ordering::SeqCst,
        Ordering::Relaxed
    );
    println!("Transition successful: {:?}", is_running);
}

功能说明

1. #[atomic_enum]宏会自动为枚举类型生成对应的原子版本，命名规则是在原枚举名前加Atomic前缀

2. 生成的原子类型提供标准的原子操作接口：

   • load - 读取当前值
   • store - 存储新值
   • swap - 交换值
   • compare_and_swap - 比较并交换
   • compare_exchange - 比较并交换(更强大的版本)

3. 该库保证跨平台兼容性，在不同架构上都能正确工作

4. 支持所有标准的内存顺序(Ordering)参数

完整示例代码

use portable_atomic_enum_macros::atomic_enum;
use std::sync::atomic::Ordering;
use std::thread;

// 定义一个线程状态枚举
#[atomic_enum]
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum ThreadState {
    Init,
    Ready,
    Running,
    Finished,
    Error,
}

fn main() {
    // 初始化原子状态
    let state = AtomicThreadState::new(ThreadState::Init);
    
    // 创建多个线程修改状态
    let handles: Vec<_> = (0..3).map(|i| {
        let state = state.clone();
        thread::spawn(move || {
            // 尝试将状态从Init改为Ready
            match state.compare_exchange(
                ThreadState::Init,
                ThreadState::Ready,
                Ordering::SeqCst,
                Ordering::Relaxed
            ) {
                Ok(_) => println!("Thread {}: Init -> Ready", i),
                Err(_) => println!("Thread {}: State already changed", i),
            }
            
            // 等待所有线程都Ready
            while state.load(Ordering::SeqCst) != ThreadState::Ready {
                thread::yield_now();
            }
            
            // 尝试执行任务
            if i == 0 {
                // 主工作线程将状态改为Running
                state.store(ThreadState::Running, Ordering::SeqCst);
                println!("Main thread: Ready -> Running");
                
                // 模拟工作
                thread::sleep(std::time::Duration::from_millis(100));
                
                // 工作完成
                state.store(ThreadState::Finished, Ordering::SeqCst);
                println!("Main thread: Running -> Finished");
            }
        })
    }).collect();
    
    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }
    
    // 最终状态
    println!("Final state: {:?}", state.load(Ordering::SeqCst));
}

这个示例展示了：

1. 多线程环境下安全的枚举状态转换
2. 使用compare_exchange进行原子状态变更
3. 使用load检查当前状态
4. 使用store直接更新状态
5. 跨线程共享原子枚举状态

注意事项

1. 枚举的变体数量不能超过底层原子类型的大小限制
2. 对于复杂的枚举类型，确保所有变体都可以安全地进行原子操作
3. 根据实际场景选择合适的内存顺序(Ordering)参数