Rust随机数生成库random的使用指南

random是Rust中一个高性能的随机数生成库，提供了多种随机数生成器和概率分布功能。

基本使用方法

添加依赖

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

[dependencies]
random = "0.16"

基本随机数生成

use random::Source;

fn main() {
    let mut source = random::default(42); // 使用默认生成器，种子为42
    
    // 生成随机整数
    let x: i32 = source.read();
    println!("随机整数: {}", x);
    
    // 生成随机浮点数 [0.0, 1.0)
    let y: f64 = source.read();
    println!("随机浮点数: {}", y);
}

高级功能

使用不同的随机数生成器

use random::{Source, Xorshift128Plus};

fn main() {
    // 使用Xorshift128+算法
    let mut source = Xorshift128Plus::new([1, 2]);
    
    for _ in 0..5 {
        println!("随机数: {}", source.read::<f64>());
    }
}

生成指定范围的随机数

use random::Source;

fn main() {
    let mut source = random::default(123);
    
    // 生成[0, 100)范围内的整数
    let num = source.read::<i32>() % 100;
    println!("0-100的随机数: {}", num);
    
    // 生成[10, 20)范围内的浮点数
    let num = 10.0 + source.read::<f64>() * 10.0;
    println!("10-20的随机浮点数: {}", num);
}

概率分布

random库支持多种概率分布：

均匀分布

use random::distributions::Uniform;

fn main() {
    let mut source = random::default(456);
    let uniform = Uniform::new(5.0, 10.0);
    
    for _ in 0..5 {
        println!("均匀分布随机数: {}", uniform.read(&mut source));
    }
}

正态分布

use random::distributions::Normal;

fn main() {
    let mut source = random::default(789);
    let normal = Normal::new(0.0, 1.0); // 均值0，标准差1
    
    for _ in 0..5 {
        println!("正态分布随机数: {}", normal.read(&mut source));
    }
}

指数分布

use random::distributions::Exp;

fn main() {
    let mut source = random::default(101);
    let exp = Exp::new(1.0); // λ=1.0
    
    for _ in 0..5 {
        println!("指数分布随机数: {}", exp.read(&mut source));
    }
}

性能提示

1. 对于高性能需求，考虑使用Xorshift128Plus生成器
2. 重用Source实例比反复创建新实例更高效
3. 对于加密安全需求，应使用rand库的OsRng而非本库

线程安全

默认情况下，random的生成器不是线程安全的。如果需要在多线程中使用，需要配合互斥锁：

use std::sync::Mutex;
use random::Source;

fn main() {
    let source = Mutex::new(random::default(123));
    
    std::thread::spawn(move || {
        let num = source.lock().unwrap().read::<i32>();
        println!("线程1: {}", num);
    });
    
    std::thread::spawn(move || {
        let num = source.lock().unwrap().read::<i32>();
        println!("线程2: {}", num);
    }).join().unwrap();
}

random库提供了简单高效的随机数生成功能，适合大多数非加密场景下的随机数需求。

完整示例代码

下面是一个综合使用random库各种功能的完整示例：

use random::{Source, Xorshift128Plus, distributions::{Uniform, Normal, Exp}};
use std::sync::Mutex;

fn main() {
    // 基本随机数生成
    println!("--- 基本随机数生成 ---");
    basic_random();
    
    // 使用Xorshift128+生成器
    println!("\n--- 使用Xorshift128+生成器 ---");
    xorshift_demo();
    
    // 范围随机数生成
    println!("\n--- 范围随机数生成 ---");
    range_demo();
    
    // 概率分布
    println!("\n--- 概率分布 ---");
    distributions_demo();
    
    // 多线程安全使用
    println!("\n--- 多线程安全使用 ---");
    thread_safe_demo();
}

fn basic_random() {
    let mut source = random::default(42); // 默认生成器
    
    println!("随机整数: {}", source.read::<i32>());
    println!("随机浮点数: {}", source.read::<f64>());
    println!("随机布尔值: {}", source.read::<bool>());
}

fn xorshift_demo() {
    let mut source = Xorshift128Plus::new([1, 2]);
    
    for _ in 0..3 {
        println!("Xorshift随机数: {}", source.read::<f64>());
    }
}

fn range_demo() {
    let mut source = random::default(123);
    
    // 整数范围 [0, 100)
    println!("0-100整数: {}", source.read::<i32>() % 100);
    
    // 浮点数范围 [5.0, 10.0)
    println!("5.0-10.0浮点数: {}", 5.0 + source.read::<f64>() * 5.0);
}

fn distributions_demo() {
    let mut source = random::default(456);
    
    // 均匀分布 [5, 10)
    let uniform = Uniform::new(5.0, 10.0);
    println!("均匀分布: {}", uniform.read(&mut source));
    
    // 正态分布 (μ=0, σ=1)
    let normal = Normal::new(0.0, 1.0);
    println!("正态分布: {}", normal.read(&mut source));
    
    // 指数分布 (λ=1.0)
    let exp = Exp::new(1.0);
    println!("指数分布: {}", exp.read(&mut source));
}

fn thread_safe_demo() {
    let source = Mutex::new(random::default(789));
    
    let handles: Vec<_> = (0..3).map(|i| {
        let source = source.clone();
        std::thread::spawn(move || {
            let num = source.lock().unwrap().read::<i32>() % 100;
            println!("线程{}: {}", i, num);
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
}

这个完整示例展示了random库的主要功能：

1. 基本随机数生成
2. 使用不同的随机数生成器(Xorshift128+)
3. 生成指定范围的随机数
4. 使用不同的概率分布
5. 多线程安全使用

每个功能都封装在单独的函数中，方便理解和测试。运行此程序将输出各种类型的随机数示例。