Rust多线程同步库spinning的使用，高性能自旋锁和同步原语实现并发控制

简介

spinning-rs是一个#![no_std]库，用于实现自旋锁(spinlocks)，功能类似于spin库，但提供了增强特性如SIX(shared-intent-exclusive)读写锁，以及与lock_api的集成。

安装

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

cargo add spinning

或者在Cargo.toml中添加：

spinning = "0.1.0"

使用示例

基本自旋锁使用

use spinning::Spin;

fn main() {
    // 创建一个Spin保护的数据
    let data = Spin::new(0);
    
    // 获取锁并修改数据
    {
        let mut guard = data.lock();
        *guard += 1;
    } // 锁在这里自动释放
    
    // 读取数据
    let value = *data.lock();
    println!("Data value: {}", value); // 输出: Data value: 1
}

读写锁示例

use spinning::{RwSpin, RwSpinReadGuard, RwSpinWriteGuard};

fn main() {
    let data = RwSpin::new(0);
    
    // 多个读取者可以同时访问
    {
        let read_guard1: RwSpinReadGuard<_> = data.read();
        let read_guard2: RwSpinReadGuard<_> = data.read();
        println!("Readers see: {}, {}", *read_guard1, *read_guard2);
    }
    
    // 单个写入者独占访问
    {
        let mut write_guard: RwSpinWriteGuard<_> = data.write();
        *write_guard += 1;
    }
}

完整并发控制示例

use spinning::Spin;
use std::sync::Arc;
use std::thread;

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

    // 创建10个线程并发增加计数器
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                let mut num = counter.lock();
                *num += 1;
            }
        });
        handles.push(handle);
    }

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

    println!("Final counter value: {}", *counter.lock());
    // 正确情况下应该输出: Final counter value: 10000
}

完整示例demo

下面是一个使用spinning库实现生产者消费者模型的完整示例：

use spinning::{RwSpin, RwSpinReadGuard, RwSpinWriteGuard};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

// 共享缓冲区结构
struct SharedBuffer<T> {
    data: RwSpin<Vec<T>>,
    capacity: usize,
}

impl<T> SharedBuffer<T> {
    fn new(capacity: usize) -> Self {
        SharedBuffer {
            data: RwSpin::new(Vec::with_capacity(capacity)),
            capacity,
        }
    }

    // 生产者写入数据
    fn produce(&self, item: T) {
        loop {
            {
                let mut buffer = self.data.write();
                if buffer.len() < self.capacity {
                    buffer.push(item);
                    return;
                }
            }
            thread::sleep(Duration::from_millis(10)); // 缓冲区满时短暂等待
        }
    }

    // 消费者读取数据
    fn consume(&self) -> Option<T> {
        let mut buffer = self.data.write();
        if !buffer.is_empty() {
            Some(buffer.remove(0))
        } else {
            None
        }
    }

    // 查看缓冲区大小
    fn size(&self) -> usize {
        let buffer = self.data.read();
        buffer.len()
    }
}

fn main() {
    let buffer = Arc::new(SharedBuffer::<i32>::new(10));
    let mut handles = vec![];

    // 创建3个生产者线程
    for i in 0..3 {
        let buffer = buffer.clone();
        handles.push(thread::spawn(move || {
            for j in 0..20 {
                let item = i * 100 + j;
                buffer.produce(item);
                println!("Producer {} produced: {}", i, item);
            }
        }));
    }

    // 创建2个消费者线程
    for _ in 0..2 {
        let buffer = buffer.clone();
        handles.push(thread::spawn(move || {
            for _ in 0..30 {
                if let Some(item) = buffer.consume() {
                    println!("Consumer got: {}", item);
                } else {
                    println!("Buffer empty, waiting...");
                }
                thread::sleep(Duration::from_millis(50));
            }
        }));
    }

    // 监控线程
    let buffer_clone = buffer.clone();
    handles.push(thread::spawn(move || {
        for _ in 0..10 {
            println!("Current buffer size: {}", buffer_clone.size());
            thread::sleep(Duration::from_millis(100));
        }
    }));

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

    println!("Final buffer size: {}", buffer.size());
}

特性

1. #![no_std]兼容，适合嵌入式开发
2. 提供自旋锁(Spin)和读写锁(RwSpin)实现
3. 高性能的同步原语
4. 与lock_api兼容的接口

许可证

spinning-rs采用双重许可：

• Apache License 2.0
• MIT license

可以根据需要选择任一许可证。