rust-performance

⚡ Rust 性能优化和最佳实践

⚠️ 执行原则

MUST 遵循以下Rust性能优化准则：

• MUST 利用零成本抽象
• NEVER 不必要地使用unsafe代码
• ALWAYS 进行性能基准测试
• DO NOT 过早优化牺牲可读性
• MUST 正确使用并发和并行
• ALWAYS 考虑内存布局和缓存效率

并发性能优化

    let handles: Vec<_> = (0..4).map(|_| {
        s.spawn(|_| {
            let mut results = Vec::new();
            while let Ok(item) = receiver.recv() {
                results.push(process_item(item));
            }
            results
        })
    }).collect();

    // 收集结果
    let mut final_results = Vec::new();
    for handle in handles {
        final_results.extend(handle.join().unwrap());
    }

    final_results
}).unwrap()

}

fn process_item(item: i32) -> i32 { item * 2 }

## 🔒 安全实践

### 内存安全保证
```rust
// ✅ 推荐：使用类型系统防止常见错误
#[derive(Debug, Clone)]
pub struct NonEmptyString(String);

impl NonEmptyString {
    pub fn new(s: String) -> Option<Self> {
        if s.is_empty() {
            None
        } else {
            Some(Self(s))
        }
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl std::fmt::Display for NonEmptyString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

// ✅ 推荐：范围类型防止越界
#[derive(Debug, Clone, Copy)]
pub struct RangeInclusive<T> {
    start: T,
    end: T,
}

impl<T: PartialOrd + Copy> RangeInclusive<T> {
    pub fn new(start: T, end: T) -> Option<Self> {
        if start <= end {
            Some(Self { start, end })
        } else {
            None
        }
    }

    pub fn contains(&self, value: T) -> bool {
        self.start <= value && value <= self.end
    }
}

// ✅ 推荐：PhantomData处理泛型生命周期
use std::marker::PhantomData;

struct DatabaseConnection<'a> {
    _marker: PhantomData<&'a ()>,
    // 实际连接数据...
}

impl<'a> DatabaseConnection<'a> {
    fn new() -> Self {
        Self {
            _marker: PhantomData,
        }
    }
}

FFI安全

use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int};