Rust信号量同步库std-semaphore的使用指南

std-semaphore是Rust中一个提供信号量(Semaphore)同步原语的库，用于线程间的同步与资源管理。信号量是一种经典的并发控制机制，可以限制同时访问某个资源的线程数量。

基本概念

信号量维护了一个计数器，表示可用资源的数量。主要操作包括：

• acquire(或wait): 获取资源，计数器减1
• release(或signal): 释放资源，计数器加1

使用方法

首先在Cargo.toml中添加依赖：

[dependencies]
std-semaphore = "0.1"

基本示例

use std_semaphore::Semaphore;
use std::sync::Arc;
use std::thread;

fn main() {
    // 创建一个初始值为3的信号量
    let semaphore = Arc::new(Semaphore::new(3));
    
    let mut handles = vec![];

    for i in 0..10 {
        let sem = semaphore.clone();
        handles.push(thread::spawn(move || {
            // 获取信号量许可
            sem.acquire();
            
            println!("线程 {} 获取了资源", i);
            // 模拟工作
            thread::sleep(std::time::Duration::from_secs(1));
            println!("线程 {} 释放了资源", i);
            
            // 释放信号量许可
            sem.release();
        }));
    }

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

带超时的信号量获取

use std_semaphore::Semaphore;
use std::time::Duration;

fn main() {
    let sem = Semaphore::new(1);
    
    // 第一个线程获取信号量
    sem.acquire();
    
    // 第二个线程尝试获取，但设置超时
    let result = sem.try_acquire(Duration::from_secs(1));
    
    match result {
        Ok(_) => println!("成功获取信号量"),
        Err(_) => println!("获取信号量超时"),
    }
}

使用信号量实现生产者-消费者模式

use std_semaphore::Semaphore;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let buffer = Arc::new(Mutex::new(Vec::<i32>::new()));
    let items = Arc::new(Semaphore::new(0)); // 初始没有可消费的项目
    let spaces = Arc::new(Semaphore::new(10)); // 缓冲区大小为10

    let producer = {
        let buffer = buffer.clone();
        let items = items.clone();
        let spaces = spaces.clone();
        thread::spawn(move || {
            for i in 0..20 {
                spaces.acquire(); // 等待有空位
                {
                    let mut buf = buffer.lock().unwrap();
                    buf.push(i);
                    println!("生产: {}", i);
                }
                items.release(); // 增加可消费项目
            }
        })
    };

    let consumer = {
        let buffer = buffer.clone();
        let items = items.clone();
        let spaces = spaces.clone();
        thread::spawn(move || {
            for _ in 0..20 {
                items.acquire(); // 等待有项目可消费
                let item = {
                    let mut buf = buffer.lock().unwrap();
                    buf.pop().unwrap()
                };
                println!("消费: {}", item);
                spaces.release(); // 释放空位
            }
        })
    };

    producer.join().unwrap();
    consumer.join().unwrap();
}

完整示例代码

下面是一个结合了上述所有特性的完整示例：

use std_semaphore::Semaphore;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    // 1. 基本信号量使用示例
    basic_semaphore_example();
    
    // 2. 带超时的信号量获取示例
    timeout_semaphore_example();
    
    // 3. 生产者-消费者模式示例
    producer_consumer_example();
}

fn basic_semaphore_example() {
    println!("\n=== 基本信号量示例 ===");
    let semaphore = Arc::new(Semaphore::new(3));
    let mut handles = vec![];

    for i in 0..5 {
        let sem = semaphore.clone();
        handles.push(thread::spawn(move || {
            sem.acquire();
            println!("线程 {} 获取了资源", i);
            thread::sleep(Duration::from_millis(500));
            println!("线程 {} 释放了资源", i);
            sem.release();
        }));
    }

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

fn timeout_semaphore_example() {
    println!("\n=== 带超时的信号量示例 ===");
    let sem = Arc::new(Semaphore::new(1));
    
    // 第一个线程获取并持有信号量
    let sem1 = sem.clone();
    let handle1 = thread::spawn(move || {
        sem1.acquire();
        println!("线程1获取了信号量并持有2秒");
        thread::sleep(Duration::from_secs(2));
        sem1.release();
    });
    
    // 第二个线程尝试获取但会超时
    thread::sleep(Duration::from_millis(500)); // 确保线程1先获取
    let sem2 = sem.clone();
    let handle2 = thread::spawn(move || {
        match sem2.try_acquire(Duration::from_secs(1)) {
            Ok(_) => println!("线程2成功获取信号量"),
            Err(_) => println!("线程2获取信号量超时"),
        }
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}

fn producer_consumer_example() {
    println!("\n=== 生产者-消费者示例 ===");
    let buffer = Arc::new(Mutex::new(Vec::new()));
    let items = Arc::new(Semaphore::new(0));
    let spaces = Arc::new(Semaphore::new(5)); // 限制缓冲区大小为5
    
    let producer = {
        let buffer = buffer.clone();
        let items = items.clone();
        let spaces = spaces.clone();
        thread::spawn(move || {
            for i in 1..=10 {
                spaces.acquire();
                {
                    let mut buf = buffer.lock().unwrap();
                    buf.push(i);
                    println!("生产者添加: {}", i);
                }
                items.release();
                thread::sleep(Duration::from_millis(200));
            }
        })
    };
    
    let consumer = {
        let buffer = buffer.clone();
        let items = items.clone();
        let spaces = spaces.clone();
        thread::spawn(move || {
            for _ in 1..=10 {
                items.acquire();
                let item = {
                    let mut buf = buffer.lock().unwrap();
                    buf.pop().unwrap()
                };
                println!("消费者取出: {}", item);
                spaces.release();
                thread::sleep(Duration::from_millis(300));
            }
        })
    };
    
    producer.join().unwrap();
    consumer.join().unwrap();
}

注意事项

1. std-semaphore不是标准库的一部分，但API设计类似于标准库风格
2. 信号量通常与Arc一起使用，以便在线程间共享
3. 注意避免死锁情况，确保所有获取的信号量最终都会被释放
4. 对于复杂场景，可以考虑结合Mutex或RwLock一起使用

信号量是强大的并发控制工具，特别适合需要限制资源访问数量的场景，如连接池、限流等。