高效能鎖定機制 Parking Lot 與 Sequence Lock

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;

struct ParkingLot {
    mutex: Arc<Mutex<()>>,
    state: AtomicUsize,
}

impl ParkingLot {
    fn new() -> Self {
        ParkingLot {
            mutex: Arc::new(Mutex::new(())),
            state: AtomicUsize::new(0),
        }
    }

    fn lock(&self) {
        // 使用 CAS 操作嘗試取得鎖
        if self.state.compare_exchange(0, 1, Ordering::Acquire, Ordering::Relaxed).is_err() {
            // 取得鎖失敗，將執行緒加入等待佇列
            let mutex = self.mutex.clone();
            let _guard = mutex.lock().unwrap();
            // 重新嘗試取得鎖
        }
    }

    fn unlock(&self) {
        self.state.store(0, Ordering::Release);
        // 通知等待佇列中的執行緒
    }
}

#### 內容解密：
1. **使用 AtomicUsize 實作鎖狀態**：`state` 欄位用於表示鎖的狀態，0 表示未鎖定，1 表示鎖定。
2. **CAS 操作取得鎖**：使用 `compare_exchange` 方法嘗試將鎖狀態從 0 修改為 1，若失敗則表示鎖已被佔用。
3. **等待佇列機制**：當鎖取得失敗時，將執行緒加入等待佇列，並重新嘗試取得鎖。
4. **解鎖操作**：將鎖狀態設為 0，並通知等待佇列中的執行緒。

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

struct SequenceLock<T> {
    data: T,
    sequence: AtomicUsize,
}

impl<T> SequenceLock<T> {
    fn new(data: T) -> Self {
        SequenceLock {
            data,
            sequence: AtomicUsize::new(0),
        }
    }

    fn write(&self, new_data: T) {
        self.sequence.fetch_add(1, Ordering::SeqCst); // 變為奇數
        self.data = new_data;
        self.sequence.fetch_add(1, Ordering::SeqCst); // 變為偶數
    }

    fn read(&self) -> Option<T>
    where
        T: Clone,
    {
        let before = self.sequence.load(Ordering::SeqCst);
        if before % 2 != 0 {
            return None; // 資料正在更新中
        }
        let data_copy = self.data.clone();
        let after = self.sequence.load(Ordering::SeqCst);
        if before == after {
            Some(data_copy)
        } else {
            None // 資料在讀取過程中被更新
        }
    }
}

#### 內容解密：
1. **資料與計數器**：`data` 欄位儲存實際資料，`sequence` 欄位作為計數器。
2. **寫入操作**：寫入前後分別更新計數器，確保讀取執行緒能檢測到更新過程。
3. **讀取操作**：透過比較讀取前後的計數器值，判斷資料是否在讀取過程中被更新。
4. **非阻塞特性**：讀取操作不會阻塞寫入操作，適合高平行場景。

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

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

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

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

    println!("最終計數: {}", counter.load(Ordering::SeqCst));
}

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

struct SpinLock {
    locked: AtomicBool,
}

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

    fn lock(&self) {
        loop {
            if self.locked.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed).is_ok() {
                break;
            }
            // 自旋等待
            thread::yield_now();
        }
    }

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

fn main() {
    let lock = Arc::new(SpinLock::new());
    let mut handles = vec![];

    for _ in 0..10 {
        let lock_clone = Arc::clone(&lock);
        let handle = thread::spawn(move || {
            lock_clone.lock();
            println!("執行緒獲得鎖");
            lock_clone.unlock();
        });
        handles.push(handle);
    }

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