use std::sync::atomic::{AtomicI32, AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;

fn main() {
    let counter = Arc::new(AtomicI32::new(0));
    let mut handles = vec![];

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

    for h in handles { h.join().unwrap(); }
    println!("计数: {}", counter.load(Ordering::SeqCst));
}

use std::sync::atomic::{AtomicI32, Ordering};

fn main() {
    let val = AtomicI32::new(0);

    // Compare-And-Swap
    loop {
        let current = val.load(Ordering::SeqCst);
        let new = current + 1;
        match val.compare_exchange_weak(
            current, new, Ordering::SeqCst, Ordering::Relaxed
        ) {
            Ok(_) => break,
            Err(_) => continue,  // 重试
        }
    }

    println!("值: {}", val.load(Ordering::SeqCst));
}

use std::sync::atomic::Ordering;

// Relaxed: 最弱，只保证原子性
// Release: 写入时使用
// Acquire: 读取时使用
// AcqRel: 读写都用
// SeqCst: 最强（默认推荐）

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

struct SpinLock {
    locked: AtomicBool,
}

impl SpinLock {
    fn new() -> Self {
        SpinLock { locked: AtomicBool::new(false) }
    }

    fn lock(&self) {
        while self.locked.compare_exchange_weak(
            false, true, Ordering::Acquire, Ordering::Relaxed
        ).is_err() {
            std::hint::spin_loop();
        }
    }

    fn unlock(&self) {
        self.locked.store(false, Ordering::Release);
    }
}