前言

💡 痛点: C/C++ 内存安全问题频发？Go 的 GC 停顿影响延迟敏感场景？Python/Node 性能瓶颈难以突破？跨平台编译和部署复杂？

🎯 解决方案: Rust 零成本抽象 + 所有权系统保证内存安全，Tokio 异步运行时实现高并发，WASM 打通浏览器与原生边界，构建高性能、安全、跨平台的系统级应用。

---

一、所有权与生命周期深度解析

1.1 所有权规则

// ownership.rs - 所有权核心规则
// 规则1: 每个值有且只有一个所有者
// 规则2: 同一时刻只能有一个可变引用 或 多个不可变引用
// 规则3: 值离开作用域时自动释放

fn ownership_basics() {
    // ======== 所有权转移（Move） ========
    let s1 = String::from("hello");
    let s2 = s1;  // s1 的所有权转移到 s2，s1 不再有效
    // println!("{}", s1);  // 编译错误：value borrowed after move
    println!("{}", s2);  // OK

    // ======== 克隆（Clone） ========
    let s3 = s2.clone();  // 深拷贝
    println!("s2: {}, s3: {}", s2, s3);  // 两者都有效

    // ======== Copy 语义（栈上数据） ========
    let x = 5;
    let y = x;  // 整数实现了 Copy trait，不会 move
    println!("x: {}, y: {}", x, y);  // 两者都有效

    // ======== 函数传参与返回 ========
    let s = String::from("hello");
    takes_ownership(s);  // s 的所有权移交给函数
    // println!("{}", s);  // 编译错误

    let x = 5;
    makes_copy(x);  // x 是 Copy 类型，仍然有效
    println!("{}", x);  // OK
}

fn takes_ownership(s: String) {
    println!("{}", s);
}  // s 离开作用域，被 drop

fn makes_copy(x: i32) {
    println!("{}", x);
}  // x 离开作用域，但因为是 Copy 类型，不会 drop

1.2 借用与引用

// borrowing.rs - 借用规则
fn borrowing_rules() {
    let mut s = String::from("hello");

    // ======== 不可变引用 ========
    let r1 = &s;  // 不可变借用
    let r2 = &s;  // 可以有多个不可变引用
    println!("{} {}", r1, r2);

    // ======== 可变引用 ========
    let r3 = &mut s;  // 可变借用
    r3.push_str(" world");
    println!("{}", r3);

    // ======== 借用规则冲突示例 ========
    // let r4 = &s;      // 编译错误：不能在可变引用存在时创建不可变引用
    // let r5 = &mut s;  // 编译错误：同一时刻只能有一个可变引用

    // ======== 非词法作用域生命周期（NLL） ========
    let mut s2 = String::from("hello");
    let r1 = &s2;
    println!("{}", r1);  // r1 最后一次使用在这里
    // NLL 之后，r1 不再被使用，可以创建可变引用
    let r2 = &mut s2;
    r2.push_str(" world");
    println!("{}", r2);
}

// ======== 切片引用 ========
fn slice_examples() {
    let s = String::from("hello world");

    // 字符串切片
    let hello = &s[0..5];
    let world = &s[6..11];
    println!("{} {}", hello, world);

    // 数组切片
    let arr = [1, 2, 3, 4, 5];
    let slice = &arr[1..3];
    println!("{:?}", slice);  // [2, 3]
}

1.3 生命周期标注

// lifetimes.rs - 生命周期标注
// 生命周期确保引用始终有效

// ======== 函数中的生命周期 ========
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn lifetime_in_functions() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("short");
        result = longest(&string1, &string2);
        println!("Longest: {}", result);
    }
    // println!("{}", result);  // 编译错误：string2 已离开作用域
}

// ======== 结构体中的生命周期 ========
struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

fn struct_lifetimes() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };
    println!("Excerpt: {}", excerpt.part);
}

// ======== 生命周期省略规则 ========
// 规则1: 每个引用参数都获得一个生命周期参数
// 规则2: 如果只有一个输入生命周期参数，它被赋予所有输出生命周期参数
// 规则3: 如果有多个输入生命周期参数但其中一个是 &self 或 &mut self，self 的生命周期被赋予所有输出生命周期参数

fn first_word(s: &str) -> &str {  // 省略生命周期标注
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

// ======== 静态生命周期 ========
fn static_lifetime() {
    let s: &'static str = "I have a static lifetime.";  // 嵌入二进制文件
    println!("{}", s);
}

---

二、Tokio 异步运行时

2.1 Tokio 核心概念

// tokio-basics.rs
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::spawn;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Tokio 异步运行时启动");

    // ======== 创建异步任务 ========
    let handle1 = tokio::spawn(async {
        println!("Task 1 started");
        sleep(Duration::from_millis(100)).await;
        println!("Task 1 completed");
        42
    });

    let handle2 = tokio::spawn(async {
        println!("Task 2 started");
        sleep(Duration::from_millis(50)).await;
        println!("Task 2 completed");
        "hello"
    });

    // ======== 等待任务完成 ========
    let result1 = handle1.await??;
    let result2 = handle2.await??;
    println!("Results: {}, {}", result1, result2);

    Ok(())
}

// ======== TCP Echo Server ========
async fn echo_server() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("Echo server listening on 127.0.0.1:8080");

    loop {
        let (mut socket, addr) = listener.accept().await?;
        println!("New connection from {}", addr);

        // 为每个连接创建异步任务
        tokio::spawn(async move {
            let mut buf = [0; 1024];

            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return,  // 连接关闭
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("Read error: {}", e);
                        return;
                    }
                };

                // 回显数据
                if let Err(e) = socket.write_all(&buf[..n]).await {
                    eprintln!("Write error: {}", e);
                    return;
                }
            }
        });
    }
}

2.2 Future 与 async/await

// futures.rs - Future trait 深度解析
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// ======== Future trait 定义 ========
pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

// ======== 手动实现 Future ========
struct Delay {
    duration: Duration,
    started: bool,
}

impl Future for Delay {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if !self.started {
            // 注册唤醒器
            let waker = cx.waker().clone();
            let duration = self.duration;
            
            thread::spawn(move || {
                thread::sleep(duration);
                waker.wake();
            });
            
            self.started = true;
            return Poll::Pending;
        }

        Poll::Ready(())
    }
}

// ======== async fn 是 Future 的语法糖 ========
async fn my_async_function() -> i32 {
    println!("Start async function");
    sleep(Duration::from_millis(100)).await;
    println!("After sleep");
    42
}

// 等价于：
fn my_async_function_desugared() -> impl Future<Output = i32> {
    async {
        println!("Start async function");
        sleep(Duration::from_millis(100)).await;
        println!("After sleep");
        42
    }
}

// ======== 组合 Future ========
async fn combine_futures() {
    // 并发执行多个 Future
    let (result1, result2, result3) = tokio::join!(
        async_operation(1),
        async_operation(2),
        async_operation(3),
    );
    println!("Results: {}, {}, {}", result1, result2, result3);

    // 竞争执行，返回最快完成的
    let result = tokio::select! {
        r1 = async_operation(1) => format!("Op1: {}", r1),
        r2 = async_operation(2) => format!("Op2: {}", r2),
    };
    println!("First to complete: {}", result);
}

async fn async_operation(id: u32) -> u32 {
    sleep(Duration::from_millis(100 * id)).await;
    id * 10
}

2.3 高性能网络服务

// high-performance-server.rs
use tokio::net::TcpListener;
use tokio::sync::mpsc;
use tokio::time::{timeout, Duration};
use bytes::Bytes;
use mini_redis::{Connection, Frame};

// ======== 多层任务调度架构 ========
pub struct Server {
    listener: TcpListener,
    // 任务间通信通道
    task_sender: mpsc::Sender<Task>,
}

pub struct Task {
    stream: TcpStream,
}

impl Server {
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
        // 创建任务分发器
        let (task_sender, mut task_receiver) = mpsc::channel::<Task>(1024);

        // 启动工作线程池
        for _ in 0..4 {
            let receiver = task_receiver.clone();
            tokio::spawn(async move {
                while let Some(task) = receiver.recv().await {
                    process_connection(task.stream).await;
                }
            });
        }

        // 主循环：接受连接并分发任务
        loop {
            let (stream, _) = self.listener.accept().await?;
            let sender = task_sender.clone();

            tokio::spawn(async move {
                let task = Task { stream };
                if let Err(e) = sender.send(task).await {
                    eprintln!("Task send error: {}", e);
                }
            });
        }
    }
}

// ======== 连接处理（带超时和限流） ========
async fn process_connection(mut stream: TcpStream) {
    let mut connection = Connection::new(stream);

    loop {
        // 设置读取超时
        let frame = match timeout(Duration::from_secs(5), connection.read_frame()).await {
            Ok(Ok(Some(frame))) => frame,
            Ok(Ok(None)) => return,  // 连接关闭
            Ok(Err(e)) => {
                eprintln!("Read error: {}", e);
                return;
            }
            Err(_) => {
                println!("Read timeout");
                return;
            }
        };

        // 处理命令
        let response = match frame {
            Frame::Set(cmd) => handle_set(cmd).await,
            Frame::Get(cmd) => handle_get(cmd).await,
            _ => Frame::Error("Unknown command".to_string()),
        };

        // 写入响应
        if let Err(e) = connection.write_frame(&response).await {
            eprintln!("Write error: {}", e);
            return;
        }
    }
}

// ======== Tokio 调度器配置 ========
#[tokio::main(flavor = "multi_thread", worker_threads = 8)]
async fn main() {
    // 多线程调度器，8个工作线程
    println!("Multi-threaded runtime with 8 workers");
}

#[tokio::main(flavor = "current_thread")]
async fn main_current_thread() {
    // 单线程调度器（适用于 I/O 密集型轻量任务）
    println!("Current-thread runtime");
}

---

三、零成本抽象与性能优化

3.1 迭代器与闭包

// zero_cost_abstractions.rs
// Rust 的迭代器和闭包是零成本抽象，编译后与手写循环性能相同

fn zero_cost_examples() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // ======== 迭代器链式调用 ========
    let result: i32 = data
        .iter()
        .filter(|&&x| x % 2 == 0)  // 过滤偶数
        .map(|&x| x * x)            // 平方
        .take(3)                     // 取前3个
        .sum();                      // 求和

    println!("Result: {}", result);  // 4 + 16 + 36 = 56

    // ======== 性能对比：迭代器 vs 手写循环 ========
    // 编译后汇编代码几乎相同！
    
    // 方式1: 迭代器
    let sum1: i32 = (0..1000).filter(|x| x % 2 == 0).sum();
    
    // 方式2: 手写循环
    let mut sum2 = 0;
    for i in 0..1000 {
        if i % 2 == 0 {
            sum2 += i;
        }
    }
    
    assert_eq!(sum1, sum2);
}

// ======== 闭包推断 ========
fn closure_examples() {
    let multiplier = 2;
    
    // 闭包自动推断类型
    let multiply = |x| x * multiplier;
    
    println!("10 * 2 = {}", multiply(10));

    // 闭包捕获环境变量的三种方式
    let mut value = 10;
    
    // FnOnce: 取得所有权
    let consume = move || {
        let v = value;  // value 被移动到闭包中
        println!("Consumed: {}", v);
    };
    consume();
    // println!("{}", value);  // 编译错误：value 已被移动
    
    // FnMut: 可变借用
    let mut value2 = 10;
    let mut increment = || {
        value2 += 1;  // 可变借用 value2
    };
    increment();
    println!("After increment: {}", value2);
    
    // Fn: 不可变借用
    let value3 = 10;
    let print = || {
        println!("Value: {}", value3);  // 不可变借用
    };
    print();
    println!("Still accessible: {}", value3);
}

3.2 泛型与单态化

// generics_monomorphization.rs
// 泛型在编译时进行单态化，生成特定类型的代码

// ======== 泛型函数 ========
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn monomorphization_demo() {
    let numbers = vec![34, 50, 12, 100, 65];
    let result1 = largest(&numbers);
    
    let chars = vec!['y', 'm', 'a', 'q'];
    let result2 = largest(&chars);
    
    // 编译器会生成两个版本的 largest 函数：
    // fn largest_i32(list: &[i32]) -> &i32 { ... }
    // fn largest_char(list: &[char]) -> &char { ... }
    // 这就是单态化（Monomorphization）
}

// ======== 泛型结构体 ========
struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

// 为特定类型实现方法
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

// ======== Trait 对象 vs 泛型 ========
trait Draw {
    fn draw(&self);
}

struct Screen<T: Draw> {
    components: Vec<T>,
}

impl<T: Draw> Screen<T> {
    fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

// 使用 Trait 对象（动态分发）
struct ScreenDyn {
    components: Vec<Box<dyn Draw>>,
}

impl ScreenDyn {
    fn run(&self) {
        for component in self.components.iter() {
            component.draw();  // 动态分发
        }
    }
}

// 性能对比：
// - 泛型 + 单态化：静态分发，编译时确定具体类型，零运行时开销
// - Trait 对象：动态分发，运行时查找虚表，有轻微性能开销但更灵活

3.3 SIMD 与内联优化

// simd_inline.rs
// 使用 SIMD 指令加速计算

#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

// ======== 手动 SIMD ========
#[cfg(target_arch = "x86_64")]
unsafe fn sum_simd(data: &[f32]) -> f32 {
    let len = data.len();
    if len < 4 {
        return data.iter().sum();
    }

    let chunks = len / 4;
    let remainder = len % 4;

    // 初始化累加器
    let mut sum = _mm_setzero_ps();

    for i in 0..chunks {
        let offset = i * 4;
        let values = _mm_loadu_ps(data.as_ptr().add(offset));
        sum = _mm_add_ps(sum, values);
    }

    // 提取结果
    let mut result = [0.0f32; 4];
    _mm_storeu_ps(result.as_mut_ptr(), sum);
    let mut total = result[0] + result[1] + result[2] + result[3];

    // 处理剩余元素
    for i in (chunks * 4)..len {
        total += data[i];
    }

    total
}

// ======== 编译器自动向量化 ========
fn sum_auto_vectorized(data: &[f32]) -> f32 {
    data.iter().sum()  // 编译器会自动优化为 SIMD 指令
}

// ======== 内联提示 ========
#[inline(always)]  // 强制内联
fn add_inline(a: i32, b: i32) -> i32 {
    a + b
}

#[inline(never)]  // 禁止内联
fn add_no_inline(a: i32, b: i32) -> i32 {
    a + b
}

// ======== 性能基准测试 ========
#[cfg(test)]
mod benches {
    use super::*;
    use std::time::Instant;

    #[test]
    fn benchmark_simd() {
        let data: Vec<f32> = (0..1_000_000).map(|i| i as f32).collect();

        let start = Instant::now();
        let sum1 = data.iter().sum::<f32>();
        let duration1 = start.elapsed();

        let start = Instant::now();
        #[cfg(target_arch = "x86_64")]
        let sum2 = unsafe { sum_simd(&data) };
        let duration2 = start.elapsed();

        println!("Scalar sum: {} ({:?})", sum1, duration1);
        #[cfg(target_arch = "x86_64")]
        println!("SIMD sum: {} ({:?})", sum2, duration2);
    }
}

---

四、WASM 模块化开发

4.1 wasm-bindgen 基础

// wasm-bindgen-basics.rs
use wasm_bindgen::prelude::*;

// ======== 导出函数到 JavaScript ========
#[wasm_bindgen]
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

// ======== 导出结构体 ========
#[wasm_bindgen]
pub struct Counter {
    count: i32,
}

#[wasm_bindgen]
impl Counter {
    #[wasm_bindgen(constructor)]
    pub fn new() -> Counter {
        Counter { count: 0 }
    }

    pub fn increment(&mut self) {
        self.count += 1;
    }

    pub fn get(&self) -> i32 {
        self.count
    }
}

// ======== 调用 JavaScript 函数 ========
#[wasm_bindgen]
extern "C" {
    // 声明外部 JavaScript 函数
    #[wasm_bindgen(js_namespace = console)]
    fn log(s: &str);

    #[wasm_bindgen(js_namespace = Math)]
    fn random() -> f64;

    #[wasm_bindgen(js_namespace = document)]
    fn getElementById(id: &str) -> JsValue;
}

#[wasm_bindgen]
pub fn call_js() {
    log("Called from Rust!");
    let rand = random();
    log(&format!("Random number: {}", rand));
}

// ======== 处理 JavaScript 对象 ========
use js_sys::{Array, Object, Reflect};
use web_sys::{HtmlElement, Document};

#[wasm_bindgen]
pub fn manipulate_dom() -> Result<(), JsValue> {
    let document = web_sys::window()
        .expect("No window")
        .document()
        .expect("No document");

    let element = document.create_element("div")?;
    element.set_text_content(Some("Hello from Rust WASM!"));

    let body = document.body().expect("No body");
    body.append_child(&element)?;

    Ok(())
}

4.2 WASM 内存管理

// wasm-memory.rs
use wasm_bindgen::prelude::*;
use js_sys::{ArrayBuffer, Uint8Array};

// ======== 线性内存 ========
#[wasm_bindgen]
pub fn memory_example() {
    // WASM 使用线性内存，可以直接访问
    let memory = wasm_bindgen::memory();
    let buffer = ArrayBuffer::new(&memory);

    // 直接操作内存
    unsafe {
        let ptr = 0x1000 as *mut u8;
        *ptr = 42;
    }
}

// ======== 传递二进制数据 ========
#[wasm_bindgen]
pub fn process_binary(data: &[u8]) -> Vec<u8> {
    // 数据从 JavaScript 传入，零拷贝
    let mut result = data.to_vec();
    result.reverse();
    result
}

#[wasm_bindgen]
pub fn create_binary() -> Vec<u8> {
    // 返回二进制数据到 JavaScript
    vec![1, 2, 3, 4, 5]
}

// ======== 使用 wasm-bindgen-futures ========
use wasm_bindgen_futures::JsFuture;
use web_sys::Response;

#[wasm_bindgen]
pub async fn fetch_url(url: String) -> Result<String, JsValue> {
    let window = web_sys::window().expect("No window");
    let response_value = JsFuture::from(window.fetch_with_str(&url)).await?;
    let response: Response = response_value.dyn_into()?;
    
    let text = JsFuture::from(response.text()?).await?;
    Ok(text.as_string().unwrap_or_default())
}

4.3 WASM 运行时嵌入

// wasm-embedder.rs
// 使用 wasmer 或 wasmtime 在 Rust 中嵌入 WASM 运行时

use wasmer::{Store, Module, Instance, Value, imports};

fn run_wasm_module() -> Result<(), Box<dyn std::error::Error>> {
    // 创建存储
    let mut store = Store::default();

    // 编译 WASM 模块
    let module_bytes = include_bytes!("module.wasm");
    let module = Module::new(&store, module_bytes)?;

    // 导入对象
    let import_object = imports! {
        "env" => {
            "memory" => wasmer::Memory::new(&mut store, wasmer::MemoryType::new(1, None, false))?,
        },
    };

    // 实例化模块
    let instance = Instance::new(&mut store, &module, &import_object)?;

    // 调用导出函数
    let add = instance.exports.get_function("add")?;
    let result = add.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
    
    println!("Result: {:?}", result);

    Ok(())
}

// ======== 使用 wasmtime ========
use wasmtime::*;

fn run_wasmtime() -> Result<(), Box<dyn std::error::Error>> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "module.wasm")?;

    let mut store = Store::new(&engine, ());

    let instance = Instance::new(&mut store, &module, &[])?;

    let add = instance.get_typed_func::<(i32, i32), i32>(&mut store, "add")?;
    let result = add.call(&mut store, (1, 2))?;

    println!("Result: {}", result);

    Ok(())
}

---

五、实战案例：高性能 CLI 工具

5.1 命令行解析

// cli-tool.rs
use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "mytool")]
#[command(about = "A high-performance CLI tool", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Enable verbose output
    #[arg(short, long, global = true)]
    verbose: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Search for a pattern in a file
    Search {
        /// Pattern to search for
        #[arg(short, long)]
        pattern: String,

        /// Input file path
        #[arg(short, long)]
        input: PathBuf,

        /// Case insensitive search
        #[arg(short, long)]
        ignore_case: bool,
    },

    /// Process a file
    Process {
        /// Input file path
        input: PathBuf,

        /// Output file path
        #[arg(short, long)]
        output: Option<PathBuf>,

        /// Number of parallel workers
        #[arg(short, long, default_value = "4")]
        workers: usize,
    },
}

fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Search { pattern, input, ignore_case } => {
            search_file(&pattern, &input, ignore_case, cli.verbose);
        }
        Commands::Process { input, output, workers } => {
            process_file(&input, output.as_deref(), workers, cli.verbose);
        }
    }
}

fn search_file(pattern: &str, input: &PathBuf, ignore_case: bool, verbose: bool) {
    use std::fs::File;
    use std::io::{BufRead, BufReader};
    use regex::RegexBuilder;

    if verbose {
        println!("Searching for '{}' in {:?}", pattern, input);
    }

    let file = File::open(input).expect("Failed to open file");
    let reader = BufReader::new(file);

    let re = RegexBuilder::new(pattern)
        .case_insensitive(ignore_case)
        .build()
        .expect("Invalid regex");

    for (line_num, line) in reader.lines().enumerate() {
        let line = line.expect("Failed to read line");
        if re.is_match(&line) {
            println!("{}: {}", line_num + 1, line);
        }
    }
}

fn process_file(input: &PathBuf, output: Option<&PathBuf>, workers: usize, verbose: bool) {
    use rayon::prelude::*;
    use std::fs;

    if verbose {
        println!("Processing {:?} with {} workers", input, workers);
    }

    // 并行处理
    let data: Vec<String> = fs::read_to_string(input)
        .expect("Failed to read file")
        .lines()
        .map(String::from)
        .collect();

    let processed: Vec<String> = data
        .par_iter()  // 并行迭代
        .map(|line| line.to_uppercase())
        .collect();

    let result = processed.join("\n");

    if let Some(output_path) = output {
        fs::write(output_path, result).expect("Failed to write output");
    } else {
        println!("{}", result);
    }
}

5.2 并行处理与 Rayon

// parallel_processing.rs
use rayon::prelude::*;
use std::collections::HashMap;

// ======== 并行迭代 ========
fn parallel_examples() {
    let data: Vec<i32> = (1..=1_000_000).collect();

    // 并行求和
    let sum: i32 = data.par_iter().sum();
    println!("Sum: {}", sum);

    // 并行过滤和映射
    let even_squares: Vec<i32> = data
        .par_iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * x)
        .collect();

    // 并行分组
    let groups: HashMap<bool, Vec<i32>> = data
        .par_iter()
        .fold(
            || HashMap::new(),
            |mut acc, &x| {
                acc.entry(x % 3 == 0).or_default().push(x);
                acc
            },
        )
        .reduce(
            || HashMap::new(),
            |mut a, b| {
                for (k, v) in b {
                    a.entry(k).or_default().extend(v);
                }
                a
            },
        );

    println!("Divisible by 3: {}", groups.get(&true).map(|v| v.len()).unwrap_or(0));
}

// ======== 并行文件处理 ========
use std::fs;
use std::path::Path;

fn process_files_parallel(dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
    let files: Vec<_> = fs::read_dir(dir)?
        .filter_map(|entry| entry.ok())
        .map(|entry| entry.path())
        .collect();

    files.par_iter().for_each(|file| {
        if let Ok(content) = fs::read_to_string(file) {
            let word_count = content.split_whitespace().count();
            println!("{:?}: {} words", file, word_count);
        }
    });

    Ok(())
}

// ======== 并行计算密集型任务 ========
fn parallel_compute() {
    let matrix_a: Vec<Vec<f64>> = generate_matrix(1000, 1000);
    let matrix_b: Vec<Vec<f64>> = generate_matrix(1000, 1000);

    // 并行矩阵乘法
    let result: Vec<Vec<f64>> = matrix_a
        .par_iter()
        .map(|row| {
            (0..matrix_b[0].len())
                .into_par_iter()
                .map(|j| {
                    row.iter()
                        .zip(matrix_b.iter().map(|r| r[j]))
                        .map(|(a, b)| a * b)
                        .sum()
                })
                .collect()
        })
        .collect();

    println!("Matrix multiplication completed");
}

fn generate_matrix(rows: usize, cols: usize) -> Vec<Vec<f64>> {
    (0..rows)
        .map(|_| (0..cols).map(|_| rand::random()).collect())
        .collect()
}

5.3 错误处理与日志

// error_handling.rs
use thiserror::Error;
use anyhow::{Context, Result};
use tracing::{info, warn, error, instrument};
use tracing_subscriber;

// ======== 自定义错误类型 ========
#[derive(Error, Debug)]
pub enum MyError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Parse error: {0}")]
    Parse(String),

    #[error("Not found: {0}")]
    NotFound(String),

    #[error("Invalid input: {message}")]
    InvalidInput { message: String },
}

// ======== 使用 anyhow 进行错误传播 ========
fn read_config(path: &str) -> Result<Config> {
    let content = std::fs::read_to_string(path)
        .with_context(|| format!("Failed to read config file: {}", path))?;
    
    let config: Config = toml::from_str(&content)
        .with_context(|| "Failed to parse config")?;
    
    Ok(config)
}

// ======== 结构化日志 ========
#[instrument(skip(data))]
fn process_data(data: &[u8]) -> Result<()> {
    info!(len = data.len(), "Processing data");
    
    if data.is_empty() {
        warn!("Empty data received");
        return Err(MyError::InvalidInput {
            message: "Data cannot be empty".to_string(),
        }.into());
    }
    
    // 处理数据
    let result = parse_data(data)?;
    
    info!("Data processed successfully");
    Ok(())
}

fn init_logging() {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .with_target(false)
        .with_thread_ids(true)
        .with_file(true)
        .with_line_number(true)
        .init();
}

// ======== main 函数 ========
fn main() -> Result<()> {
    init_logging();
    
    info!("Application started");
    
    let config = read_config("config.toml")?;
    info!(database = %config.database.url, "Config loaded");
    
    let data = fetch_data()?;
    process_data(&data)?;
    
    info!("Application completed");
    Ok(())
}

#[derive(Debug, Deserialize)]
struct Config {
    database: DatabaseConfig,
}

#[derive(Debug, Deserialize)]
struct DatabaseConfig {
    url: String,
}

fn fetch_data() -> Result<Vec<u8>> {
    Ok(vec![1, 2, 3, 4, 5])
}

fn parse_data(data: &[u8]) -> Result<()> {
    // 解析逻辑
    Ok(())
}

---

六、Checklist 总结

□ 所有权系统
  □ 所有权规则（Move/Clone/Copy）
  □ 借用规则（可变/不可变引用）
  □ 生命周期标注（函数/结构体）
  □ 生命周期省略规则
  □ 静态生命周期

□ Tokio 异步运行时
  □ #[tokio::main] 启动
  □ spawn 创建异步任务
  □ Future trait 实现
  □ async/await 语法
  □ 多线程/单线程调度器
  □ join!/select! 组合器
  □ 通道通信（mpsc/oneshot/broadcast）

□ 零成本抽象
  □ 迭代器性能等同于手写循环
  □ 闭包捕获（Fn/FnMut/FnOnce）
  □ 泛型单态化
  □ Trait 对象 vs 泛型
  □ SIMD 手动/自动向量化
  □ 内联优化

□ WASM 模块化
  □ wasm-bindgen 导出函数/结构体
  □ 调用 JavaScript 函数
  □ 处理 JS 对象和 DOM
  □ 内存管理和二进制数据
  □ wasm-bindgen-futures
  □ WASM 运行时嵌入（wasmer/wasmtime）

□ CLI 工具开发
  □ clap 命令行解析
  □ Rayon 并行处理
  □ 错误处理（thiserror/anyhow）
  □ 结构化日志（tracing）
  □ 性能优化和基准测试

---

总结

一句话总结： Rust 通过所有权系统实现内存安全，Tokio 提供高效异步运行时，零成本抽象保证性能，WASM 打通跨平台边界，是构建高性能系统级应用的现代首选。

核心技术对比：

领域	传统方案	Rust 方案	优势
内存管理	手动管理/GC	所有权系统	零运行时开销 + 内存安全
并发模型	线程池/回调地狱	async/await + Future	零成本抽象 + 无数据竞争
错误处理	异常/错误码	Result + ? 操作符	显式 + 强制处理
跨平台	多语言实现	WASM 单代码库	一次编写，处处运行
性能	依赖编译器优化	零成本抽象 + SIMD	可预测的高性能