Rust原子操作库atomig的使用指南

介绍

atomig是一个轻量级的Rust原子操作库，提供了跨平台的原子类型实现。该库专注于为多线程环境下的并发编程提供安全、高效的原子操作支持，帮助开发者避免数据竞争和并发访问问题。

主要特性

• 提供多种原子类型（AtomicBool、AtomicI32、AtomicU64等）
• 支持多种内存排序（Relaxed、Acquire、Release等）
• 跨平台兼容性
• 零成本抽象

安装方法

在Cargo.toml中添加依赖：

[dependencies]
atomig = "0.3"

基本使用方法

1. 创建原子变量

use atomig::Atomic;

let atomic_bool = Atomic::new(false);
let atomic_int = Atomic::new(0i32);

2. 基本原子操作

use atomig::{Atomic, Ordering};

let atomic = Atomic::new(5);

// 存储值
atomic.store(10, Ordering::SeqCst);

// 加载值
let value = atomic.load(Ordering::SeqCst);
println!("当前值: {}", value);

// 比较并交换
let result = atomic.compare_exchange(
    10, 
    15, 
    Ordering::SeqCst, 
    Ordering::Relaxed
);

3. 原子算术操作

let atomic = Atomic::new(0u32);

// 原子加法
let prev = atomic.fetch_add(5, Ordering::SeqCst);
println!("加法前值: {}, 加法后值: {}", prev, atomic.load(Ordering::SeqCst));

// 原子减法
atomic.fetch_sub(2, Ordering::SeqCst);

// 原子与操作
atomic.fetch_and(0xFF, Ordering::SeqCst);

4. 多线程安全示例

use std::sync::Arc;
use std::thread;
use atomig::{Atomic, Ordering};

let counter = Arc::new(Atomic::new(0));

let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        for _ in 0..1000 {
            counter.fetch_add(1, Ordering::SeqCst);
        }
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

println!("最终计数: {}", counter.load(Ordering::SeqCst));

5. 内存排序示例

use atomig::{Atomic, Ordering};

let data = Atomic::new(0);
let flag = Atomic::new(false);

// 线程1：发布数据
data.store(42, Ordering::Relaxed);
flag.store(true, Ordering::Release);

// 线程2：获取数据
while !flag.load(Ordering::Acquire) {
    // 自旋等待
}
let value = data.load(Ordering::Relaxed);
println!("获取到的数据: {}", value);

完整示例demo

use std::sync::Arc;
use std::thread;
use atomig::{Atomic, Ordering};

fn main() {
    // 示例1：基本原子操作
    println!("=== 基本原子操作示例 ===");
    let atomic_counter = Atomic::new(0i32);
    
    // 存储新值
    atomic_counter.store(10, Ordering::SeqCst);
    
    // 加载当前值
    let current_value = atomic_counter.load(Ordering::SeqCst);
    println!("当前计数值: {}", current_value);
    
    // 比较并交换操作
    match atomic_counter.compare_exchange(
        10,
        15,
        Ordering::SeqCst,
        Ordering::Relaxed
    ) {
        Ok(prev) => println!("比较交换成功，之前的值: {}", prev),
        Err(current) => println!("比较交换失败，当前值: {}", current),
    }

    // 示例2：原子算术操作
    println!("\n=== 原子算术操作示例 ===");
    let atomic_number = Atomic::new(0u32);
    
    // 原子加法
    let prev_add = atomic_number.fetch_add(5, Ordering::SeqCst);
    println!("加法前: {}, 加法后: {}", prev_add, atomic_number.load(Ordering::SeqCst));
    
    // 原子减法
    let prev_sub = atomic_number.fetch_sub(2, Ordering::SeqCst);
    println!("减法前: {}, 减法后: {}", prev_sub, atomic_number.load(Ordering::SeqCst));
    
    // 原子与操作
    atomic_number.fetch_and(0b1111, Ordering::SeqCst);
    println!("与操作后: {}", atomic_number.load(Ordering::SeqCst));

    // 示例3：多线程计数器
    println!("\n=== 多线程计数器示例 ===");
    let shared_counter = Arc::new(Atomic::new(0));
    let mut threads = vec![];

    // 创建10个线程，每个线程增加计数器100次
    for _ in 0..10 {
        let counter_ref = Arc::clone(&shared_counter);
        let thread = thread::spawn(move || {
            for _ in 0..100 {
                counter_ref.fetch_add(1, Ordering::SeqCst);
            }
        });
        threads.push(thread);
    }

    // 等待所有线程完成
    for thread in threads {
        thread.join().unwrap();
    }

    println!("最终计数器值: {}", shared_counter.load(Ordering::SeqCst));

    // 示例4：内存排序示例
    println!("\n=== 内存排序示例 ===");
    let data = Atomic::new(0);
    let flag = Atomic::new(false);
    
    // 模拟线程1：发布数据
    data.store(42, Ordering::Relaxed);
    flag.store(true, Ordering::Release);
    println!("线程1: 数据已发布");
    
    // 模拟线程2：获取数据
    while !flag.load(Ordering::Acquire) {
        // 自旋等待标志位
        std::thread::yield_now();
    }
    let received_data = data.load(Ordering::Relaxed);
    println!("线程2: 获取到的数据: {}", received_data);
}

注意事项

1. 根据具体场景选择合适的内存排序级别
2. 避免过度使用原子操作，可能影响性能
3. 在需要时考虑使用Mutex或其他同步原语

性能建议

• 对于计数器等简单场景，优先使用Relaxed排序
• 需要严格同步时使用SeqCst排序
• 考虑使用fetch_update进行复杂操作

这个库为Rust开发者提供了简单易用的原子操作接口，是构建高性能并发应用的理想选择。