langShift

系统级编程与高级主题

学习 Rust 的系统级编程特性,包括 unsafe 代码、宏系统、性能优化和底层编程

系统级编程与高级主题

📖 学习目标

理解 Rust 的系统级编程特性,学会使用 unsafe 代码、宏系统、性能优化技术,掌握底层编程概念。


🎯 系统级编程对比

JavaScript 的高级抽象

JavaScript 运行在虚拟机中,提供高级抽象:

正在加载...

Rust 的系统级编程

Rust 提供直接的内存控制和系统级访问:

正在加载...

系统级编程差异

  1. 内存控制: Rust 提供直接内存控制,JavaScript 自动管理
  2. 性能: Rust 零成本抽象,JavaScript 有运行时开销
  3. 安全性: Rust 编译时保证内存安全,JavaScript 运行时检查
  4. 系统访问: Rust 可以直接调用系统 API,JavaScript 受沙箱限制

⚠️ Unsafe 代码

何时使用 Unsafe

正在加载...

🔧 宏系统

声明宏和过程宏

正在加载...

⚡ 性能优化

性能优化技术

正在加载...

🎯 练习题

练习 1: 实现自定义智能指针

创建一个引用计数的智能指针:

查看答案
use std::sync::{Arc, Mutex};
struct RefCounted<T> {
data: Arc<Mutex<T>>,
}
impl<T> RefCounted<T> {
fn new(data: T) -> Self {
Self {
data: Arc::new(Mutex::new(data)),
}
}
fn get(&self) -> Option<T>
where
T: Clone,
{
self.data.lock().ok().map(|guard| (*guard).clone())
}
fn set(&self, value: T) -> Result<(), String> {
self.data
.lock()
.map(|mut guard| *guard = value)
.map_err(|_| "无法获取锁".to_string())
}
fn strong_count(&self) -> usize {
Arc::strong_count(&self.data)
}
}
impl<T> Clone for RefCounted<T> {
fn clone(&self) -> Self {
Self {
data: Arc::clone(&self.data),
}
}
}
fn main() {
let ptr1 = RefCounted::new(42);
println!("引用计数: {}", ptr1.strong_count());
let ptr2 = ptr1.clone();
println!("引用计数: {}", ptr1.strong_count());
ptr1.set(100).unwrap();
println!("ptr1 值: {:?}", ptr1.get());
println!("ptr2 值: {:?}", ptr2.get());
}

练习 2: 创建性能优化的数据结构

实现一个缓存友好的矩阵乘法:

查看答案
struct Matrix {
data: Vec<f64>,
rows: usize,
cols: usize,
}
impl Matrix {
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: &Matrix) -> Option<Matrix> {
if self.cols != other.rows {
return None;
}
let mut result = Matrix::new(self.rows, other.cols);
// 使用分块乘法优化缓存性能
let block_size = 32;
for i in (0..self.rows).step_by(block_size) {
for j in (0..other.cols).step_by(block_size) {
for k in (0..self.cols).step_by(block_size) {
// 处理当前块
let i_end = (i + block_size).min(self.rows);
let j_end = (j + block_size).min(other.cols);
let k_end = (k + block_size).min(self.cols);
for ii in i..i_end {
for jj in j..j_end {
let mut sum = 0.0;
for kk in k..k_end {
sum += self.get(ii, kk) * other.get(kk, jj);
}
result.set(ii, jj, result.get(ii, jj) + sum);
}
}
}
}
}
Some(result)
}
}
fn main() {
let mut a = Matrix::new(100, 100);
let mut b = Matrix::new(100, 100);
// 初始化矩阵
for i in 0..100 {
for j in 0..100 {
a.set(i, j, (i + j) as f64);
b.set(i, j, (i * j) as f64);
}
}
if let Some(result) = a.multiply(&b) {
println!("矩阵乘法完成,结果矩阵大小: {}x{}", result.rows, result.cols);
}
}

练习 3: 实现自定义宏

创建一个用于生成测试代码的宏:

查看答案
macro_rules! generate_tests {
($test_name:ident, $input:expr, $expected:expr) => {
#[test]
fn $test_name() {
let result = $input;
assert_eq!(result, $expected);
}
};
($test_name:ident, $input:expr, $expected:expr, $($extra_assert:expr);*) => {
#[test]
fn $test_name() {
let result = $input;
assert_eq!(result, $expected);
$($extra_assert;)*
}
};
}
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn multiply(a: i32, b: i32) -> i32 {
a * b
}
// 使用宏生成测试
generate_tests!(test_add, add(2, 3), 5);
generate_tests!(test_multiply, multiply(4, 5), 20);
generate_tests!(
test_add_with_extra,
add(10, 20),
30,
assert!(add(10, 20) > 0);
assert!(add(10, 20) < 100)
);
fn main() {
println!("运行测试...");
test_add();
test_multiply();
test_add_with_extra();
println!("所有测试通过!");
}

📝 总结

在这一章中,我们学习了 Rust 的系统级编程特性:

  1. 系统级编程: 直接内存控制和系统访问
  2. Unsafe 代码: 何时使用和如何安全地使用
  3. 宏系统: 声明宏和过程宏的使用
  4. 性能优化: 内存布局、缓存友好性和 SIMD
  5. 与 JavaScript 对比: 底层控制 vs 高级抽象

关键要点

  • Rust 提供零成本抽象和系统级控制
  • Unsafe 代码需要谨慎使用,确保安全性
  • 宏系统提供强大的代码生成能力
  • 性能优化需要理解底层硬件特性

下一步学习

在下一章中,我们将学习 Rust 的实战项目,通过完整的项目来巩固所学知识。


继续学习: 实战项目驱动