当前位置：首页 > news >正文

Rust底层编程：安全与性能的完美平衡

news 2025/11/10 7:57:47

在这里插入图片描述

Rust的核心优势在于能够在提供高级抽象的同时保持系统级编程的性能和控制力。本章将深入探索不安全Rust、FFI、内存布局和底层系统编程技术。

第三十九章：不安全Rust

39.1 不安全操作的基础

// 不安全代码块和函数
unsafe fn dangerous_operation() -> *mut u8 {let mut data = 42u8;&mut data as *mut u8
}// 解引用原始指针
fn raw_pointers_example() {let mut num = 10;// 创建原始指针let r1 = &num as *const i32;let r2 = &mut num as *mut i32;unsafe {println!("r1 指向: {}", *r1);println!("r2 指向: {}", *r2);*r2 = 20;println!("修改后: {}", *r1);}
}// 调用不安全函数
extern "C" {fn abs(input: i32) -> i32;
}fn call_unsafe_function() {unsafe {println!("C abs(-10) = {}", abs(-10));}
}// 可变静态变量
static mut COUNTER: u32 = 0;fn increment_counter() {unsafe {COUNTER += 1;}
}fn static_mutation_example() {for _ in 0..10 {increment_counter();}unsafe {println!("计数器值: {}", COUNTER);}
}#[cfg(test)]
mod unsafe_tests {use super::*;#[test]fn test_raw_pointers() {raw_pointers_example();}#[test] fn test_static_mutation() {static_mutation_example();}
}fn main() {println!("=== 不安全Rust基础 ===");raw_pointers_example();call_unsafe_function();static_mutation_example();// 不安全traitunsafe_trait_example();
}// 不安全trait
unsafe trait UnsafeTrait {fn dangerous_method(&self);
}unsafe impl UnsafeTrait for i32 {fn dangerous_method(&self) {println!("不安全的方法调用: {}", self);}
}fn unsafe_trait_example() {let value = 42;unsafe {value.dangerous_method();}
}

39.2 安全抽象封装

use std::slice;// 安全包装不安全代码
struct SafeBuffer {data: *mut u8,len: usize,capacity: usize,
}impl SafeBuffer {fn new(capacity: usize) -> Self {unsafe {let layout = std::alloc::Layout::from_size_align(capacity, 1).expect("无效的布局");let data = std::alloc::alloc(layout);Self {data,len: 0,capacity,}}}fn push(&mut self, value: u8) -> Result<(), &'static str> {if self.len >= self.capacity {return Err("缓冲区已满");}unsafe {*self.data.add(self.len) = value;}self.len += 1;Ok(())}fn as_slice(&self) -> &[u8] {unsafe {slice::from_raw_parts(self.data, self.len)}}fn as_mut_slice(&mut self) -> &mut [u8] {unsafe {slice::from_raw_parts_mut(self.data, self.len)}}
}impl Drop for SafeBuffer {fn drop(&mut self) {unsafe {let layout = std::alloc::Layout::from_size_align(self.capacity, 1).expect("无效的布局");std::alloc::dealloc(self.data, layout);}}
}// 安全的FFI包装
mod ffi_wrapper {use std::ffi::CString;use std::os::raw::c_char;extern "C" {pub fn strlen(s: *const c_char) -> usize;pub fn strcpy(dest: *mut c_char, src: *const c_char) -> *mut c_char;}pub struct CStringWrapper {ptr: *mut c_char,}impl CStringWrapper {pub fn new(s: &str) -> Option<Self> {let c_string = CString::new(s).ok()?;let ptr = c_string.into_raw();Some(Self { ptr })}pub fn len(&self) -> usize {unsafe {strlen(self.ptr)}}pub fn as_ptr(&self) -> *const c_char {self.ptr}}impl Drop for CStringWrapper {fn drop(&mut self) {unsafe {let _ = CString::from_raw(self.ptr);}}}
}// 内存安全迭代器
struct SafeRawIter<T> {start: *const T,end: *const T,
}impl<T> SafeRawIter<T> {fn new(slice: &[T]) -> Self {Self {start: slice.as_ptr(),end: unsafe { slice.as_ptr().add(slice.len()) },}}
}impl<T> Iterator for SafeRawIter<T> {type Item = *const T;fn next(&mut self) -> Option<Self::Item> {if self.start == self.end {None} else {let current = self.start;unsafe {self.start = self.start.add(1);}Some(current)}}
}fn main() {println!("=== 安全抽象封装 ===");// SafeBuffer使用let mut buffer = SafeBuffer::new(10);for i in 0..5 {buffer.push(i).unwrap();}println!("缓冲区内容: {:?}", buffer.as_slice());// CStringWrapper使用if let Some(c_str) = ffi_wrapper::CStringWrapper::new("Hello, FFI!") {println!("C字符串长度: {}", c_str.len());}// SafeRawIter使用let data = vec![1, 2, 3, 4, 5];let iter = SafeRawIter::new(&data);for ptr in iter {unsafe {println!("指针指向: {}", *ptr);}}// 高级安全抽象advanced_safe_abstractions();
}fn advanced_safe_abstractions() {println!("\n=== 高级安全抽象 ===");// 零拷贝解析器let bytes = b"Hello, World!";let parser = ZeroCopyParser::new(bytes);if let Some(slice) = parser.get_slice(0, 5) {println!("零拷贝切片: {:?}", std::str::from_utf8(slice).unwrap());}
}struct ZeroCopyParser<'a> {data: &'a [u8],
}impl<'a> ZeroCopyParser<'a> {fn new(data: &'a [u8]) -> Self {Self { data }}fn get_slice(&self, start: usize, len: usize) -> Option<&'a [u8]> {if start + len <= self.data.len() {Some(&self.data[start..start + len])} else {None}}
}

第四十章：FFI和外部函数接口

40.1 C语言互操作

// 在Cargo.toml中添加：
// [dependencies]
// libc = "0.2"use libc::{c_int, c_void, size_t};// 基本的C函数声明
extern "C" {pub fn malloc(size: size_t) -> *mut c_void;pub fn free(ptr: *mut c_void);pub fn memset(s: *mut c_void, c: c_int, n: size_t) -> *mut c_void;pub fn memcpy(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void;
}// 安全的C内存包装器
struct CMemory {ptr: *mut c_void,size: usize,
}impl CMemory {fn new(size: usize) -> Option<Self> {unsafe {let ptr = malloc(size);if ptr.is_null() {None} else {// 初始化内存memset(ptr, 0, size);Some(Self { ptr, size })}}}fn as_slice(&self) -> &[u8] {unsafe {std::slice::from_raw_parts(self.ptr as *const u8, self.size)}}fn as_mut_slice(&mut self) -> &mut [u8] {unsafe {std::slice::from_raw_parts_mut(self.ptr as *mut u8, self.size)}}fn copy_from(&mut self, data: &[u8]) -> Result<(), &'static str> {if data.len() > self.size {return Err("数据太大");}unsafe {memcpy(self.ptr, data.as_ptr() as *const c_void, data.len());}Ok(())}
}impl Drop for CMemory {fn drop(&mut self) {unsafe {free(self.ptr);}}
}// C结构体绑定
#[repr(C)]
#[derive(Debug, Copy, Clone)]
struct CPoint {x: c_int,y: c_int,
}#[repr(C)]
#[derive(Debug)]
struct CRect {top_left: CPoint,bottom_right: CPoint,
}// C风格函数
extern "C" {fn create_point(x: c_int, y: c_int) -> CPoint;fn calculate_area(rect: *const CRect) -> c_int;
}// Rust到C的回调函数
type CCallback = extern "C" fn(data: *const c_void, len: size_t) -> c_int;extern "C" fn rust_callback(data: *const c_void, len: size_t) -> c_int {unsafe {let slice = std::slice::from_raw_parts(data as *const u8, len);println!("C回调收到数据: {:?}", slice);slice.len() as c_int}
}#[cfg(test)]
mod ffi_tests {use super::*;#[test]fn test_c_memory() {let mut mem = CMemory::new(100).unwrap();let test_data = b"Hello, C memory!";mem.copy_from(test_data).unwrap();assert_eq!(&mem.as_slice()[..test_data.len()], test_data);}
}fn main() {println!("=== FFI和C互操作 ===");// C内存管理let mut c_memory = CMemory::new(50).unwrap();let data = b"Hello from Rust!";c_memory.copy_from(data).unwrap();println!("C内存内容: {:?}", &c_memory.as_slice()[..data.len()]);// C结构体使用let point = CPoint { x: 10, y: 20 };let rect = CRect {top_left: point,bottom_right: CPoint { x: 30, y: 40 },};println!("C矩形: {:?}", rect);// 回调函数演示println!("回调函数演示完成");// 复杂FFI场景advanced_ffi_scenarios();
}fn advanced_ffi_scenarios() {println!("\n=== 高级FFI场景 ===");// 字符串转换let rust_string = "Hello, 世界!";let c_string = std::ffi::CString::new(rust_string).unwrap();println!("Rust字符串: {}", rust_string);println!("C字符串指针: {:?}", c_string.as_ptr());// 错误处理match std::panic::catch_unwind(|| {// 可能panic的FFI代码let _memory = CMemory::new(usize::MAX);}) {Ok(_) => println!("FFI调用成功"),Err(_) => println!("FFI调用失败"),}
}

40.2 与其他语言互操作

// Python扩展 (需要配置Cargo.toml和build.rs)
#[cfg(feature = "python")]
mod python_ffi {use pyo3::prelude::*;use pyo3::wrap_pyfunction;#[pyfunction]fn rust_fibonacci(n: u64) -> u64 {if n <= 1 {n} else {rust_fibonacci(n - 1) + rust_fibonacci(n - 2)}}#[pyfunction]fn process_data(data: Vec<i32>) -> PyResult<Vec<i32>> {let processed: Vec<i32> = data.into_iter().map(|x| x * 2).filter(|&x| x > 10).collect();Ok(processed)}#[pymodule]fn rust_extensions(_py: Python, m: &PyModule) -> PyResult<()> {m.add_function(wrap_pyfunction!(rust_fibonacci, m)?)?;m.add_function(wrap_pyfunction!(process_data, m)?)?;Ok(())}
}// Node.js N-API (概念性代码)
#[cfg(feature = "nodejs")]
mod node_ffi {use napi::bindgen_prelude::*;use napi_derive::napi;#[napi]pub fn add(a: i32, b: i32) -> i32 {a + b}#[napi]pub fn get_stats(numbers: Vec<f64>) -> Object {let sum: f64 = numbers.iter().sum();let count = numbers.len() as f64;let mean = if count > 0.0 { sum / count } else { 0.0 };// 返回JavaScript对象let mut stats = Object::new();stats.set("sum", sum).unwrap();stats.set("mean", mean).unwrap();stats.set("count", numbers.len() as i32).unwrap();stats}
}// WebAssembly导出
#[cfg(target_arch = "wasm32")]
mod wasm_export {use wasm_bindgen::prelude::*;#[wasm_bindgen]pub fn greet(name: &str) -> String {format!("Hello, {} from Rust!", name)}#[wasm_bindgen]pub struct Calculator {value: i32,}#[wasm_bindgen]impl Calculator {#[wasm_bindgen(constructor)]pub fn new() -> Self {Self { value: 0 }}pub fn add(&mut self, n: i32) -> i32 {self.value += n;self.value}pub fn get_value(&self) -> i32 {self.value}}
}// 通用FFI工具函数
mod ffi_utils {use std::ffi::{CStr, CString};use std::os::raw::c_char;/// 安全地将C字符串转换为Rust字符串pub unsafe fn c_str_to_string(ptr: *const c_char) -> Option<String> {if ptr.is_null() {None} else {CStr::from_ptr(ptr).to_str().ok().map(|s| s.to_string())}}/// 将Rust字符串转换为C字符串pub fn string_to_c_string(s: &str) -> Result<*mut c_char, std::ffi::NulError> {CString::new(s).map(|c_str| c_str.into_raw())}/// 释放C字符串pub unsafe fn free_c_string(ptr: *mut c_char) {if !ptr.is_null() {let _ = CString::from_raw(ptr);}}
}fn main() {println!("=== 多语言互操作 ===");// 演示通用FFI工具let rust_str = "Hello, FFI!";unsafe {match ffi_utils::string_to_c_string(rust_str) {Ok(c_str) => {if let Some(converted) = ffi_utils::c_str_to_string(c_str) {println!("转换成功: {}", converted);}ffi_utils::free_c_string(c_str);}Err(e) => println!("转换失败: {}", e),}}println!("多语言互操作演示完成");
}

第四十一章：内存布局和优化

41.1 内存布局控制

use std::mem;// 显式控制内存布局
#[repr(C)]
struct CCompatible {a: u32,b: u64, c: u16,
}#[repr(packed)]
struct PackedData {flag: u8,data: u32,
}#[repr(align(64))]
struct CacheAligned {data: [f64; 8],
}// 零大小类型优化
struct Empty;struct WithEmpty {data: u32,_empty: Empty,
}// 手动内存管理
struct ManualVec<T> {ptr: *mut T,len: usize,capacity: usize,
}impl<T> ManualVec<T> {fn new() -> Self {Self {ptr: std::ptr::null_mut(),len: 0,capacity: 0,}}fn push(&mut self, value: T) {if self.len >= self.capacity {self.grow();}unsafe {let end = self.ptr.add(self.len);std::ptr::write(end, value);}self.len += 1;}fn grow(&mut self) {let new_capacity = if self.capacity == 0 { 4 } else { self.capacity * 2 };let new_size = new_capacity * mem::size_of::<T>();let align = mem::align_of::<T>();unsafe {let new_ptr = if self.capacity == 0 {let layout = std::alloc::Layout::from_size_align(new_size, align).expect("无效的布局");std::alloc::alloc(layout) as *mut T} else {let old_size = self.capacity * mem::size_of::<T>();let old_layout = std::alloc::Layout::from_size_align(old_size, align).expect("无效的布局");let new_layout = std::alloc::Layout::from_size_align(new_size, align).expect("无效的布局");std::alloc::realloc(self.ptr as *mut u8, old_layout, new_size) as *mut T};self.ptr = new_ptr;self.capacity = new_capacity;}}fn get(&self, index: usize) -> Option<&T> {if index < self.len {unsafe {Some(&*self.ptr.add(index))}} else {None}}
}impl<T> Drop for ManualVec<T> {fn drop(&mut self) {if !self.ptr.is_null() {unsafe {// 调用析构函数for i in 0..self.len {std::ptr::drop_in_place(self.ptr.add(i));}// 释放内存let size = self.capacity * mem::size_of::<T>();let align = mem::align_of::<T>();let layout = std::alloc::Layout::from_size_align(size, align).expect("无效的布局");std::alloc::dealloc(self.ptr as *mut u8, layout);}}}
}// 内存映射模拟
struct MemoryMapping {start: usize,size: usize,
}impl MemoryMapping {fn new(size: usize) -> Option<Self> {// 在实际系统中，这里会调用系统API创建内存映射Some(Self {start: 0x1000, // 模拟地址size,})}fn as_slice(&self) -> &[u8] {unsafe {std::slice::from_raw_parts(self.start as *const u8, self.size)}}fn as_mut_slice(&mut self) -> &mut [u8] {unsafe {std::slice::from_raw_parts_mut(self.start as *mut u8, self.size)}}
}fn main() {println!("=== 内存布局和优化 ===");// 内存布局信息println!("CCompatible 大小: {}", mem::size_of::<CCompatible>());println!("PackedData 大小: {}", mem::size_of::<PackedData>());println!("CacheAligned 大小: {}", mem::size_of::<CacheAligned>());println!("WithEmpty 大小: {}", mem::size_of::<WithEmpty>());// ManualVec使用let mut manual_vec = ManualVec::new();for i in 0..10 {manual_vec.push(i * 2);}for i in 0..manual_vec.len {if let Some(value) = manual_vec.get(i) {println!("manual_vec[{}] = {}", i, value);}}// 内存映射演示if let Some(mut mapping) = MemoryMapping::new(1024) {let slice = mapping.as_mut_slice();slice[0] = 42;println!("内存映射第一个字节: {}", slice[0]);}// 高级内存优化advanced_memory_optimizations();
}fn advanced_memory_optimizations() {println!("\n=== 高级内存优化 ===");// 栈上分配大型数组let stack_array: [u8; 1024] = [0; 1024];println!("栈数组大小: {}", stack_array.len());// 使用MaybeUninit延迟初始化use std::mem::MaybeUninit;let mut uninit_array: MaybeUninit<[u32; 1000]> = MaybeUninit::uninit();// 安全地初始化部分数据unsafe {let init_part = &mut (*uninit_array.as_mut_ptr())[0..100];for (i, elem) in init_part.iter_mut().enumerate() {*elem = i as u32;}}println!("MaybeUninit数组部分初始化完成");// 内存池模式let mut pool = MemoryPool::new(1024);let block1 = pool.allocate(64).unwrap();let block2 = pool.allocate(128).unwrap();println!("内存池分配: {} 和 {}", block1.size, block2.size);
}struct MemoryBlock {start: usize,size: usize,
}struct MemoryPool {memory: Vec<u8>,allocations: Vec<MemoryBlock>,
}impl MemoryPool {fn new(size: usize) -> Self {Self {memory: vec![0; size],allocations: Vec::new(),}}fn allocate(&mut self, size: usize) -> Option<MemoryBlock> {// 简单的首次适应分配算法let mut current_pos = 0;for block in &self.allocations {let gap = block.start - current_pos;if gap >= size {// 找到足够大的空隙let new_block = MemoryBlock {start: current_pos,size,};self.allocations.push(new_block);return Some(new_block);}current_pos = block.start + block.size;}// 检查末尾空间if current_pos + size <= self.memory.len() {let new_block = MemoryBlock {start: current_pos,size,};self.allocations.push(new_block);Some(new_block)} else {None}}
}

41.2 性能优化模式

use std::hint::black_box;
use std::time::Instant;// 内联优化
#[inline(always)]
fn fast_add(a: i32, b: i32) -> i32 {a + b
}#[inline(never)]
fn slow_computation(a: i32, b: i32) -> i32 {// 模拟复杂计算let mut result = 0;for i in 0..1000 {result += a * b + i;}result
}// 分支预测优化
fn branch_optimized_sum(data: &[i32]) -> i32 {let mut sum = 0;// 提前计算长度避免边界检查let len = data.len();for i in 0..len {// 使用get_unchecked避免边界检查unsafe {sum += *data.get_unchecked(i);}}sum
}// 缓存友好的数据布局
#[derive(Clone)]
struct CacheFriendlyMatrix {data: Vec<f64>,rows: usize,cols: usize,
}impl CacheFriendlyMatrix {fn new(rows: usize, cols: usize) -> Self {Self {data: vec![0.0; rows * cols],rows,cols,}}fn get(&self, row: usize, col: usize) -> f64 {self.data[row * self.cols + col]}fn set(&mut self, row: usize, col: usize, value: f64) {self.data[row * self.cols + col] = value;}// 缓存友好的矩阵乘法fn multiply(&self, other: &Self) -> Option<Self> {if self.cols != other.rows {return None;}let mut result = Self::new(self.rows, other.cols);// 优化：循环重排以提高缓存局部性for i in 0..self.rows {for k in 0..self.cols {let a_ik = self.get(i, k);for j in 0..other.cols {let b_kj = other.get(k, j);let current = result.get(i, j);result.set(i, j, current + a_ik * b_kj);}}}Some(result)}
}// 零拷贝数据转换
trait ZeroCopyConvert {type Output;fn convert(&self) -> &Self::Output;
}impl ZeroCopyConvert for [u8; 4] {type Output = u32;fn convert(&self) -> &u32 {unsafe { &*(self.as_ptr() as *const u32) }}
}// 性能测量工具
struct Benchmark {start: Instant,name: String,
}impl Benchmark {fn new(name: &str) -> Self {Self {start: Instant::now(),name: name.to_string(),}}fn elapsed(&self) -> std::time::Duration {self.start.elapsed()}
}impl Drop for Benchmark {fn drop(&mut self) {let duration = self.elapsed();println!("{} 耗时: {:?}", self.name, duration);}
}fn main() {println!("=== 性能优化模式 ===");// 内联优化演示let _bench1 = Benchmark::new("内联优化");for i in 0..1000000 {black_box(fast_add(i, i * 2));}let _bench2 = Benchmark::new("非内联优化");for i in 0..1000 {black_box(slow_computation(i, i * 2));}// 分支预测优化let data: Vec<i32> = (0..10000).collect();let _bench3 = Benchmark::new("分支优化求和");let sum = branch_optimized_sum(&data);println!("求和结果: {}", sum);// 缓存友好矩阵let _bench4 = Benchmark::new("矩阵乘法");let a = CacheFriendlyMatrix::new(100, 100);let b = CacheFriendlyMatrix::new(100, 100);if let Some(result) = a.multiply(&b) {println!("矩阵乘法完成，结果大小: {}x{}", result.rows, result.cols);}// 零拷贝转换let bytes = [0x78, 0x56, 0x34, 0x12]; // 小端序的 0x12345678let number: &u32 = bytes.convert();println!("零拷贝转换结果: 0x{:x}", number);// 高级优化技术advanced_optimization_techniques();
}fn advanced_optimization_techniques() {println!("\n=== 高级优化技术 ===");// SIMD优化 (概念性)#[cfg(target_arch = "x86_64")]{use std::arch::x86_64::*;unsafe {let a = _mm_set1_ps(1.0);let b = _mm_set1_ps(2.0);let result = _mm_add_ps(a, b);let mut output = [0.0f32; 4];_mm_store_ps(output.as_mut_ptr(), result);println!("SIMD加法结果: {:?}", output);}}// 内存预取模式let mut data = vec![0u64; 10000];let _bench = Benchmark::new("内存预取优化");for i in 0..data.len() {// 手动预取下一个缓存行if i + 8 < data.len() {#[cfg(target_arch = "x86_64")]unsafe {use std::arch::x86_64::_mm_prefetch;let next_addr = data.as_ptr().add(i + 8) as *const i8;_mm_prefetch(next_addr, _MM_HINT_T0);}}data[i] = data[i].wrapping_mul(1664525).wrapping_add(1013904223);}println!("内存预取优化完成");
}

第四十二章：系统级编程

42.1 低级系统调用

use std::fs::File;
use std::io::{self, Read, Write};
use std::os::unix::io::{AsRawFd, RawFd};// 原始文件操作
struct RawFile {fd: RawFd,
}impl RawFile {fn open(path: &str) -> io::Result<Self> {let file = File::open(path)?;Ok(Self { fd: file.as_raw_fd() })}fn read_exact(&self, buf: &mut [u8]) -> io::Result<()> {let mut file = unsafe { File::from_raw_fd(self.fd) };let result = file.read_exact(buf);std::mem::forget(file); // 防止关闭文件描述符result}
}// 信号处理
#[cfg(unix)]
mod signal_handling {use libc::{c_int, sighandler_t, SIGINT, SIGTERM};use std::sync::atomic::{AtomicBool, Ordering};use std::sync::Arc;static SHOULD_EXIT: AtomicBool = AtomicBool::new(false);extern "C" fn handle_signal(_signal: c_int) {SHOULD_EXIT.store(true, Ordering::SeqCst);}pub fn setup_signal_handlers() -> Result<(), String> {unsafe {if libc::signal(SIGINT, handle_signal as sighandler_t) == libc::SIG_ERR {return Err("无法设置SIGINT处理器".to_string());}if libc::signal(SIGTERM, handle_signal as sighandler_t) == libc::SIG_ERR {return Err("无法设置SIGTERM处理器".to_string());}}Ok(())}pub fn should_exit() -> bool {SHOULD_EXIT.load(Ordering::SeqCst)}
}// 进程管理
mod process_management {use std::process::{Command, Stdio};use std::io::{BufRead, BufReader};pub struct ProcessManager;impl ProcessManager {pub fn spawn_detached(command: &str, args: &[&str]) -> std::io::Result<()> {Command::new(command).args(args).stdout(Stdio::null()).stderr(Stdio::null()).spawn()?;Ok(())}pub fn spawn_with_output(command: &str, args: &[&str]) -> std::io::Result<String> {let output = Command::new(command).args(args).output()?;if output.status.success() {Ok(String::from_utf8_lossy(&output.stdout).to_string())} else {Err(std::io::Error::new(std::io::ErrorKind::Other,format!("命令执行失败: {}", String::from_utf8_lossy(&output.stderr))))}}pub fn pipe_commands(commands: &[(&str, &[&str])]) -> std::io::Result<String> {let mut previous_output = None;for (command, args) in commands {let mut cmd = Command::new(command);cmd.args(args);if let Some(output) = previous_output.take() {cmd.stdin(output);}let output = cmd.stdout(Stdio::piped()).spawn()?;previous_output = output.stdout;}if let Some(mut final_output) = previous_output {let mut result = String::new();let mut reader = BufReader::new(&mut final_output);reader.read_to_string(&mut result)?;Ok(result)} else {Ok(String::new())}}}
}// 系统信息收集
mod system_info {use std::collections::HashMap;pub struct SystemInfo;impl SystemInfo {pub fn get_memory_info() -> HashMap<String, String> {let mut info = HashMap::new();if let Ok(meminfo) = std::fs::read_to_string("/proc/meminfo") {for line in meminfo.lines() {if let Some((key, value)) = line.split_once(':') {info.insert(key.trim().to_string(), value.trim().to_string());}}}info}pub fn get_cpu_info() -> HashMap<String, String> {let mut info = HashMap::new();if let Ok(cpuinfo) = std::fs::read_to_string("/proc/cpuinfo") {for line in cpuinfo.lines() {if let Some((key, value)) = line.split_once(':') {info.insert(key.trim().to_string(), value.trim().to_string());}}}info}}
}fn main() {println!("=== 系统级编程 ===");// 信号处理设置#[cfg(unix)]{if let Err(e) = signal_handling::setup_signal_handlers() {eprintln!("信号处理设置失败: {}", e);}}// 进程管理演示match process_management::ProcessManager::spawn_with_output("echo", &["Hello, Process!"]) {Ok(output) => println!("进程输出: {}", output),Err(e) => eprintln!("进程执行错误: {}", e),}// 系统信息收集let memory_info = system_info::SystemInfo::get_memory_info();println!("内存信息:");for (key, value) in memory_info.iter().take(3) {println!("  {}: {}", key, value);}// 原始文件操作if let Ok(raw_file) = RawFile::open("/etc/hosts") {let mut buffer = [0u8; 100];if let Ok(()) = raw_file.read_exact(&mut buffer) {println!("文件前100字节: {:?}", &buffer[..50]);}}// 长时间运行的任务，检查退出信号run_system_daemon();
}fn run_system_daemon() {println!("\n=== 系统守护进程模拟 ===");let mut counter = 0;loop {#[cfg(unix)]{if signal_handling::should_exit() {println!("收到退出信号，优雅退出");break;}}// 模拟工作counter += 1;if counter >= 5 {println!("守护进程工作完成");break;}println!("守护进程工作中... {}", counter);std::thread::sleep(std::time::Duration::from_secs(1));}
}