Rust 专题 — 从入门到系统编程的完整指南 on PlumePHP

Rust AI 与大模型集成：Candle、llm.rs 与 Python FFI

Fri, 01 Aug 2025 00:00:00 +0800

1. 为什么 Rust 适合 AI 推理

Python 主导了 AI 训练生态，但 Rust 在 AI 推理和基础设施领域崛起：

Rust Web 框架实战：Axum、Actix-web 与 Rocket 深度对比

Fri, 01 Aug 2025 00:00:00 +0800

1. 三大框架概览

特性	Axum	Actix-web	Rocket
维护方	Tokio 团队（官方）	社区（Actix）	社区（Sergio Benitez）
核心设计	Tower Service 抽象	Actor 模型	声明式宏
性能	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
学习曲线	中（需理解 Tower）	低	低
中间件	Tower layer	自定义 guard/middleware	Fairing + Guard
稳定版状态	✅ 1.0	✅ 4.x	✅ 0.5

2. Axum：Tower 生态现代框架

Axum 基于 hyper HTTP 服务器和 tower 中间件抽象，是 Tokio 官方推荐的 Web 框架。

Rust 异步与并发编程：Tokio、async/await 与并发模式

Fri, 01 Aug 2025 00:00:00 +0800

1. Rust 并发模型概览

Rust 提供三种并发方式：

方式	API	特点
OS 线程	`std::thread`	真并行，开销大
异步任务	`tokio::spawn`	协程级轻量，I/O 密集
并行计算	`rayon::join`	数据并行，CPU 密集

// OS 线程
use std::thread;
let handle = thread::spawn(|| { /* 工作 */ });
handle.join().unwrap();

2. async/await 与 Poll 模型

2.1 async 函数的本质

async fn 是语法糖，编译后生成一个实现 Future trait 的状态机：

Rust 所有权与内存安全：智能指针、内部可变性与 Unsafe 边界

Fri, 01 Aug 2025 00:00:00 +0800

1. 所有权语义深度解析

1.1 Move 语义的原理

Rust 的默认行为是 move（转移所有权），而非 copy。对于未实现 Copy trait 的类型，赋值会转移所有权：

Rust 核心概念详解：所有权、Trait 与宏系统

Fri, 01 Aug 2025 00:00:00 +0800

1. Rust 设计哲学

Rust 的设计目标是在不依赖垃圾回收器（GC）的前提下，提供内存安全和零成本抽象。这是通过编译时的所有权检查（Borrow Checker）来实现的，而非运行时的额外开销。

Rust 桌面端与 WASM：Tauri、WebAssembly 与嵌入式开发

Fri, 01 Aug 2025 00:00:00 +0800

1. Tauri：Rust 驱动的桌面应用

1.1 为什么替代 Electron

维度	Electron	Tauri
后端运行时	Node.js + Chromium	Rust + 系统 WebView
打包体积	~150MB	~3MB
内存占用	高（完整 Chromium）	低（共享系统 WebView）
安全性	中等	高（Rust 内存安全 + 进程隔离）
前端框架	任意	任意（React/Vue/Svelte/纯 HTML）

1.2 项目结构

my-tauri-app/
├── src/ # 前端代码（任意框架）
├── src-tauri/ # Rust 后端
│ ├── src/main.rs
│ ├── Cargo.toml
│ └── tauri.conf.json

1.3 核心概念：Commands

// src-tauri/src/main.rs
use tauri::command;

#[command]
fn greet(name: &str) -> String {
 format!("Hello, {}! You've been greeted from Rust.", name)
}

fn main() {
 tauri::Builder::default()
 .invoke_handler(tauri::generate_handler![greet])
 .run(tauri::generate_context!())
 .expect("error while running tauri application");
}

前端调用：

Rust 系统编程与性能优化：零拷贝、内存剖析与编译调优

Fri, 01 Aug 2025 00:00:00 +0800

1. 操作系统原语绑定

Rust 通过 libc/winapi crate 直接调用操作系统 API：

use libc::{open, O_RDONLY, read, close};
use std::os::raw::c_void;

fn raw_read(path: &str) -> Result<Vec<u8>, i32> {
 let fd = unsafe {
 let c_path = std::ffi::CString::new(path).unwrap();
 open(c_path.as_ptr(), O_RDONLY)
 };
 
 if fd < 0 {
 return Err(unsafe { *libc::__errno_location() });
 }
 
 let mut buf = vec![0u8; 4096];
 let n = unsafe { read(fd, buf.as_mut_ptr() as *mut c_void, buf.len()) };
 unsafe { close(fd); }
 
 buf.truncate(n as usize);
 Ok(buf)
}

nix crate：安全的系统调用封装

use nix::unistd::{fork, ForkResult, execvp};
use nix::sys::wait::waitpid;

match unsafe { fork() } {
 Ok(ForkResult::Child) => {
 execvp(&"ls".into(), &["ls".into(), "-la".into()]).unwrap();
 }
 Ok(ForkResult::Parent { child }) => {
 waitpid(child, None).unwrap();
 }
 Err(_) => eprintln!("Fork failed"),
}

2. 零拷贝 I/O

2.1 sendfile 系统调用

use nix::sys::sendfile::sendfile;

fn send_file(src: RawFd, dest: RawFd, offset: off_t, count: size_t) -> Result<ssize_t> {
 let mut off = offset;
 sendfile(dest, src, Some(&mut off), count)
}

2.2 splice（管道零拷贝）

use nix::fcntl::{splice, SpliceFFlags};

// 将数据从文件 splice 到 socket，不经过用户空间
splice(
 file_fd, None,
 socket_fd, None,
 4096,
 SpliceFFlags::empty(),
)?;

2.3 io_uring（Linux 异步 I/O）

use io_uring::{IoUring, opcode, types};

let mut ring = IoUring::new(32)?;

// 提交读请求
let read_e = opcode::Read::new(fd, buf.as_mut_ptr(), buf.len() as u32)
 .build()
 .user_data(0x42);

unsafe {
 ring.submission()
 .push(&read_e)
 .expect("submission queue full");
}

ring.submit_and_wait(1)?;

3. 内存映射 mmap

3.1 文件映射

use memmap2::MmapOptions;
use std::fs::File;

let file = File::open("large.bin")?;
let mmap = unsafe { MmapOptions::new().map(&file)? };

// 像访问内存一样访问文件，不占用堆内存
println!("First byte: {}", mmap[0]);

3.2 匿名映射（共享内存）

let mut mmap = MmapOptions::new()
 .len(4096)
 .map_mut()?;

mmap[..5].copy_from_slice(b"hello");

3.3 跨进程共享内存

use memmap2::MmapMut;
use std::fs::OpenOptions;

let file = OpenOptions::new()
 .read(true)
 .write(true)
 .create(true)
 .open("/dev/shm/my_shared_mem")?;
file.set_len(4096)?;

let mut mmap = unsafe { MmapMut::map_mut(&file)? };
mmap[..13].copy_from_slice(b"Hello Process");

4. 性能剖析工具链

4.1 cargo flamegraph

cargo install flamegraph

# 生成 CPU 火焰图（需 sudo 或在 Linux 上）
cargo flamegraph --bin myapp

# 打开 flamegraph.svg 查看热点

4.2 perf + cargo-profiler

# Linux perf
cargo build --release
perf record -g ./target/release/myapp
perf report

# cargo-profiler（callgrind/cachegrind）
cargo install cargo-profiler
cargo profiler callgrind --bin myapp

4.3 tokio-console

# 查看异步任务状态
cargo install tokio-console

# 代码中添加 ConsoleLayer
use console_subscriber::ConsoleLayer;
ConsoleLayer::builder().init();

# 运行
tokio-console

5. 编译器优化

5.1 Cargo.toml 优化配置

[profile.release]
opt-level = 3 # 最高优化级别
lto = true # 链接时优化
strip = true # 移除符号表，减小体积
panic = "abort" # panic 时直接 abort，不移栈
codegen-units = 1 # 减少并行编译单元，提升优化机会

[profile.release.build-override]
opt-level = 3

5.2 PGO（Profile Guided Optimization）

# 1. 编译插桩版本
RUSTFLAGS="-Cprofile-generate=/tmp/pgo" cargo build --release

# 2. 运行代表性负载
./target/release/myapp --benchmark

# 3. 合并 profile
llvm-profdata merge -o /tmp/pgo/merged.profdata /tmp/pgo

# 4. 再编译优化版本
RUSTFLAGS="-Cprofile-use=/tmp/pgo/merged.profdata" cargo build --release

5.3 target-cpu 特定优化

# 针对当前 CPU 架构优化
RUSTFLAGS="-C target-cpu=native" cargo build --release

# 针对特定架构（如 Apple M3）
RUSTFLAGS="-C target-cpu=apple-m3" cargo build --release

6. Benchmark 实践

6.1 Criterion.rs

use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
 match n {
 0 => 1,
 1 => 1,
 n => fibonacci(n - 1) + fibonacci(n - 2),
 }
}

fn criterion_benchmark(c: &mut Criterion) {
 c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);

cargo bench

6.2 内存分配基准

use stats_alloc::{StatsAlloc, Region, INSTRUMENTED_SYSTEM};
use std::alloc::System;

#[global_allocator]
static GLOBAL: StatsAlloc<System> = INSTRUMENTED_SYSTEM;

#[test]
fn test_allocations() {
 let reg = Region::new(&GLOBAL);
 let _ = process_data();
 let stats = reg.change();
 assert_eq!(stats.bytes_allocated, 1024);
 assert_eq!(stats.bytes_deallocated, 1024);
}

6.3 Iai（指令计数基准）

use iai::black_box;

fn iai_benchmark() {
 black_box(fibonacci(black_box(20)));
}

iai::main!(iai_benchmark);

7. 内存分析

7.1 dhat（堆分配追踪）

#[global_allocator]
static ALLOC: dhat::Alloc = dhat::Alloc;

fn main() {
 let _profiler = dhat::Profiler::new_heap();
 // 运行程序...
}

7.2 cargo bloat（查看二进制体积构成）

cargo install cargo-bloat

# 按大小排序的符号
cargo bloat --release -n 20

# 按 crate 分组
cargo bloat --release --crates

7.3 cargo audit（依赖安全检查）

cargo install cargo-audit
cargo audit

8. no_std 系统编程

8.1 自定义分配器

use core::alloc::{GlobalAlloc, Layout};

struct MyAllocator;

unsafe impl GlobalAlloc for MyAllocator {
 unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
 libc::malloc(layout.size()) as *mut u8
 }
 
 unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
 libc::free(ptr as *mut libc::c_void);
 }
}

#[global_allocator]
static ALLOCATOR: MyAllocator = MyAllocator;

8.2 内核模块编程

#![no_std]
#![no_main]

use linux_kernel_module::{self, println};

module! {
 type: MyModule,
 name: b"my_kernel_module",
 author: b"Developer",
 description: b"A sample module",
 license: b"GPL",
}

struct MyModule;
impl linux_kernel_module::KernelModule for MyModule {
 fn init() -> Result<Self, linux_kernel_module::Error> {
 println!("Hello from kernel module!");
 Ok(MyModule)
 }
}

Rust 在系统编程领域的独特价值：零成本抽象让高级代码编译后不输手写 C，所有权系统消除整类内存错误，现代工具链（cargo/flamegraph/profiler）让性能分析前所未有的简单。从用户态到内核态，从边缘设备到数据中心，Rust 正在重塑系统软件的编写方式。

Rust 错误处理与测试：thiserror、mockall 与属性测试

Fri, 01 Aug 2025 00:00:00 +0800

1. 错误处理哲学

Rust 的错误处理哲学：可恢复错误用 Result，不可恢复错误用 panic。没有异常机制，所有错误路径必须显式处理。

在Rust中进行原型设计的实践和优势

Tue, 21 Jan 2025 19:58:52 +0800

引言

Rust是一种系统编程语言，以其内存安全、并发性和高性能而闻名。尽管Rust通常被用于构建高性能的系统级应用程序，但它同样适用于快速原型设计。本文将详细探讨在Rust中进行原型设计的实践和优势，涵盖从环境搭建到实际开发的各个方面。

Rust生成的二进制依赖问题

Fri, 20 Dec 2024 15:01:25 +0800

Rust 生成的二进制文件的依赖问题主要与链接方式、C 语言库、标准库以及目标平台相关。在深入理解 Rust 二进制依赖问题时，我们需要了解静态链接与动态链接的概念，以及 Rust 如何处理依赖和生成最终的可执行文件。

Tauri介绍

Thu, 10 Oct 2024 14:57:22 +0800

Tauri 是一个现代的框架，用于构建轻量级、安全的跨平台桌面应用程序。它结合了 Rust 的强大功能和 Web 技术（HTML、CSS 和 JavaScript），提供了一种高效的方式来开发桌面应用。以下是 Tauri 的详细说明，包括其架构、优势、安装、创建项目、开发和部署等方面。

Rust的tikio库介绍

Thu, 22 Aug 2024 18:02:23 +0800

Tokio 是 Rust 语言的一个异步运行时，它提供了编写网络应用程序所需的构建模块，支持从大型服务器到小型嵌入式设备的多种系统。以下是 Tokio 的一些主要特性和代码示例的介绍：

Rust的跨平台特性

Mon, 19 Aug 2024 23:08:45 +0800

Rust的跨平台特性

Rust 语言的跨平台特性主要得益于其编译为特定平台机器码的能力以及其标准库和第三方库对不同操作系统的适配。以下是 Rust 跨平台实现的一些关键点：

条件编译：Rust 提供了条件编译的特性，允许开发者根据不同的操作系统编写特定的代码。例如，可以使用 #[cfg(target_os = "linux")] 来指定只有在目标操作系统为 Linux 时才编译的代码段。

Rust语言的所有权系统

Fri, 16 Aug 2024 17:51:12 +0800

Rust 语言的所有权系统是其设计的核心，它提供了一种独特的方法来管理内存，确保了内存安全和效率。下面我将详细解释所有权、借用和生命周期的概念，以及它们是如何相互关联的。

Cargo.toml文件详细说明

Fri, 16 Aug 2024 11:49:56 +0800

以下是对Cargo.toml文件其主要部分的详细解释：

`[package]` 部分

Cargo.toml的第一部分是[package]，包含关于包的基本信息：

name — 包的名称。
version — 遵循语义化版本控制的当前版本号。
authors — 包的作者列表。
edition — 指定Rust版本，如果不指定，默认为2015，最新稳定版是2021。
rust-version — 指定所需的最低Rust编译器版本。
description — 包的简短描述，crates.io会显示此描述。
documentation — 包文档的URL。
readme — 包的README文件路径。
homepage — 包主页的URL。
repository — 包源代码仓库的URL。
license — 包使用的许可证名称。
license-file — 包含许可证文本的文件路径。
keywords — 包的关键字列表，用于分类和检索。
categories — 包的分类列表。
workspace — 包所属工作区的路径。
build — 构建脚本的文件路径。
links — 包链接的本地库的名称。
exclude — 发布时排除的文件模式列表。
include — 发布时包含的文件模式列表。
publish — 控制包是否可以发布，可以设置为false以阻止发布或指定允许发布的注册服务列表。
metadata — 提供给外部工具的额外设置。

目标配置

[lib] — 库目标设置。
[[bin]] — 二进制目标设置，可以有多个以创建多个可执行文件。
[[example]] — 示例目标设置。
[[test]] — 测试目标设置。
[[bench]] — 基准测试目标设置。

依赖项

[dependencies] — 包的库依赖。
[dev-dependencies] — 仅用于examples、tests和benchmarks的依赖。
[build-dependencies] — 构建脚本的依赖。

特性和配置

[features] — 条件编译选项。
[patch] — 覆盖依赖项。
[replace] — 不推荐使用的依赖覆盖方式（已弃用）。
[profile] — 编译器设置和优化。
[workspace] — 工作区定义。

配置文件

配置文件允许您为每个包指定配置，甚至可以检入版本控制。您可以在主目录中使用配置文件指定默认值。

Rust语言在系统编程方面有哪些优势

Thu, 15 Aug 2024 18:18:04 +0800

Rust语言在系统编程方面有哪些优势

Rust语言在系统编程方面具有一系列显著的优势，这些优势使其成为开发高性能、安全和可靠系统软件的理想选择：

内存安全：Rust的所有权（ownership）、借用（borrowing）和生命周期（lifetimes）系统能够在编译时防止数据竞争和内存泄漏等问题，无需垃圾收集器。

Rust和c++的区别

Thu, 15 Aug 2024 18:11:28 +0800

Rust和C++是两种在系统编程领域广泛使用的编程语言，它们各自具有独特的优势和特点。以下是对这两种语言的深入对比分析，以及表格汇总的概述。

语言特性对比

Rust

内存管理: Rust通过所有权系统来确保内存安全，避免了使用垃圾收集器，从而提高了性能和安全性。
并发编程: Rust的所有权和借用规则天然支持安全并发，减少了数据竞争的风险。
语法和表达性: Rust的语法类似于C++，但提供了更现代的语言特性，例如模式匹配和迭代器。

C++

内存管理: C++依赖于程序员手动管理内存，虽然提供了智能指针如std::shared_ptr和std::unique_ptr来帮助管理，但仍然存在内存泄漏的风险。
并发编程: C++提供了线程库和同步原语，但需要开发者小心管理以避免死锁和竞态条件。
语法和表达性: C++的语法较为复杂，但提供了丰富的特性，如操作符重载和模板元编程。

性能对比

编译时间: Rust和C++的完整构建时间大致相同，但C++在增量编译方面通常表现更好。
运行时性能: Rust倾向于在编译时完成尽可能多的检查和优化，减少了运行时的开销，而C++具有更多的运行时决策灵活性。

社区和生态

社区支持: C++拥有更大的社区和更广泛的用例，得到了所有软件公司的认可。
库和框架: C++提供了丰富的标准库和第三方库，特别是在游戏开发领域，如虚幻引擎。Rust虽然较新，但正在快速发展其生态系统，提供了一些现代的框架和库。

应用领域

系统编程: Rust由于其内存安全特性，适合用于系统编程，如设备驱动程序和操作系统开发。
游戏开发: C++是游戏开发的主要语言，大多数市场主导的游戏都是用C++编写的。

易用性和学习曲线

易用性: Rust被认为更易于使用，具有定义良好的语义和防止不必要/未定义行为的能力。
学习曲线: C++由于其复杂的语法和特性，学习曲线较为陡峭。

表格汇总

特性/语言	Rust	C++
内存管理	所有权系统	手动/智能指针
并发编程	安全并发	锁机制
性能	编译时优化	运行时灵活
社区支持	较小但增长	较大
应用领域	系统编程	游戏开发
易用性	易于使用	学习曲线陡峭

请注意，这个表格是一个简化的汇总，实际的语言特性和性能表现可能会根据具体的使用场景和项目需求有所不同。在选择Rust或C++时，应该根据项目的具体需求、团队熟悉度以及对未来技术趋势的判断来做出决策。

安装和配置Rust开发环境

Wed, 14 Aug 2024 09:30:00 +0800

安装和配置Rust开发环境是一个相对简单的过程，主要包括安装Rust编译器、配置文本编辑器和学习使用Cargo。以下是详细的步骤说明：

安装Rust编译器

访问Rust官网：
打开浏览器，访问Rust官网。

Rust基础语法介绍

Wed, 07 Aug 2024 16:24:16 +0800

Rust是一种注重安全、速度和并发的系统编程语言。它通过所有权、借用和生命周期的概念来实现内存安全，无需垃圾回收。以下是Rust的基本语法介绍，包括代码示例和说明。

Rust语言应用场景

Tue, 06 Aug 2024 19:39:26 +0800

Rust语言应用场景

Rust语言以其安全性、速度和并发性在系统编程领域中越来越受到重视。以下是一些Rust语言的最佳应用场景和案例说明，包含有效可使用的链接：

系统编程和操作系统开发：Rust的内存安全特性使其成为开发操作系统和系统级软件的理想选择。例如，Redox OS 是一个用 Rust 编写的操作系统，展示了 Rust 在此领域的应用潜力。

WebAssembly介绍

Tue, 06 Aug 2024 15:42:01 +0800

WebAssembly（简称Wasm）是一种为现代Web浏览器设计的二进制指令格式，它提供了一种低层次的虚拟机以运行在浏览器环境中。它不是JavaScript的替代品，而是JavaScript的补充，旨在提高JavaScript的性能，允许使用C/C++等低级语言编写的代码在浏览器中以近乎原生的速度运行。

Rust基础知识入门

Wed, 31 Jul 2024 20:15:02 +0800

Rust基础知识入门

Rust 是一种系统级编程语言，以其安全性、速度和并发性而闻名。以下是一些 Rust 入门的关键知识点，以及具体的代码示例和详细说明：

Hello World 程序：这是学习任何编程语言的第一步。在 Rust 中，程序的入口点是 main 函数。

Rust中的不可变引用

Tue, 30 Jul 2024 12:16:16 +0800

在Rust中，创建一个指向某个变量的不可变引用非常简单。以下是一些基本的步骤和示例：

基本语法

定义变量：首先，你需要有一个变量。
创建不可变引用：使用&符号来创建一个不可变引用。

示例代码

fn main() {
 let x = 5; // 定义一个变量 x
 let y = &x; // 创建一个不可变引用 y，指向 x

 println!("x is: {}", x); // 打印 x 的值
 println!("y is: {}", y); // 打印 y 的值，即 x 的值
}

在函数内部创建不可变引用

如果你想在函数内部创建一个指向某个变量的不可变引用，可以这样做：

在Rust中，如何正确地使用不可变借用和可变借用

Tue, 30 Jul 2024 12:08:29 +0800

在Rust中，借用是访问数据的一种方式，可以是不可变的或可变的。正确使用不可变借用和可变借用对于避免编译错误和确保内存安全至关重要。以下是一些关键点和规则：

Rust语言的内存安全特性是如何实现的

Tue, 30 Jul 2024 12:05:29 +0800

Rust语言的内存安全特性是如何实现的

Rust语言的内存安全特性主要通过以下几个核心机制来实现：

所有权（Ownership）：
- 在Rust中，每个值都有一个被称为其所有者的变量。
- 值在任意时刻只能有一个所有者。
- 当所有者超出作用域时，值会被自动丢弃。
借用（Borrowing）：

一些rust学习资源

Mon, 29 Jul 2024 11:18:28 +0800

学习Rust语言是一个系统性的过程，涉及到从基础语法到高级特性的全面掌握。以下是一些详细的Rust学习资料推荐，包括书籍、在线教程、社区资源等，并附有链接。

在Rust中，如何避免借用冲突和悬垂指针的问题

Fri, 19 Jul 2024 19:47:37 +0800

在 Rust 中，借用冲突和悬垂指针问题是由 Rust 的所有权和借用规则来预防的。以下是一些避免这些问题的最佳实践：

避免借用冲突

理解借用规则：确保你理解 Rust 的借用规则，特别是“在任何给定时间，要么只能有一个可变引用，要么只能有多个不可变引用”的规则。

Rust语言中的所有权和借用规则具体是如何工作的

Fri, 19 Jul 2024 19:45:23 +0800

Rust 语言的所有权和借用规则是其核心特性之一，旨在在编译时确保内存安全。以下是 Rust 所有权和借用规则的具体工作原理：

所有权（Ownership）

单一所有权：在 Rust 中，每个值都有一个被称为其“所有者”的变量。一个值在任意时刻只能有一个所有者。
所有权转移：当所有者将值传递给另一个函数时，所有权会从原所有者转移到新所有者，原所有者将不能再使用该值。
所有权释放：当所有者超出作用域时，所有权会被释放，值会被自动销毁。

借用（Borrowing）

不可变借用：允许在不修改原始值的情况下访问值。可以有多个不可变借用，但它们不能与可变借用共存。
可变借用：允许修改原始值。在任意时刻，只能有一个可变借用，且不能有其他不可变借用。
借用的生命周期：借用必须在所有者的生命周期内，且不能比所有者活得更长。

规则细节

规则 1：在任何给定时间，要么只能有一个可变引用，要么只能有多个不可变引用，不能同时拥有多个可变引用和不可变引用。

Rust语言中有哪些常见的内存安全问题

Fri, 19 Jul 2024 19:33:57 +0800

Rust 语言的设计目标之一是提供内存安全，但这并不意味着 Rust 程序就不会遇到内存安全问题。以下是一些 Rust 中可能遇到的内存安全问题以及如何避免它们的建议：

空指针解引用：

Rust学习路线

Fri, 19 Jul 2024 15:51:42 +0800

Rust 是一种注重安全、速度和并发的现代系统编程语言。以下是一份详尽的 Rust 学习计划，帮助你从零开始，逐步掌握 Rust 编程语言。

第1阶段：基础概念学习

目标：了解 Rust 的基本概念和语言特性。

Rust 专题 — 从入门到系统编程的完整指南 on PlumePHP

Rust AI 与大模型集成：Candle、llm.rs 与 Python FFI

目录

1. 为什么 Rust 适合 AI 推理

Rust Web 框架实战：Axum、Actix-web 与 Rocket 深度对比

目录

1. 三大框架概览

2. Axum：Tower 生态现代框架

Rust 异步与并发编程：Tokio、async/await 与并发模式

目录

1. Rust 并发模型概览

2. async/await 与 Poll 模型

2.1 async 函数的本质

Rust 所有权与内存安全：智能指针、内部可变性与 Unsafe 边界

目录

1. 所有权语义深度解析

1.1 Move 语义的原理

Rust 核心概念详解：所有权、Trait 与宏系统

目录

1. Rust 设计哲学

Rust 桌面端与 WASM：Tauri、WebAssembly 与嵌入式开发

目录

1. Tauri：Rust 驱动的桌面应用

1.1 为什么替代 Electron

1.2 项目结构

1.3 核心概念：Commands

Rust 系统编程与性能优化：零拷贝、内存剖析与编译调优

目录

1. 操作系统原语绑定

nix crate：安全的系统调用封装

2. 零拷贝 I/O

2.1 sendfile 系统调用

2.2 splice（管道零拷贝）

2.3 io_uring（Linux 异步 I/O）

3. 内存映射 mmap

3.1 文件映射

3.2 匿名映射（共享内存）

3.3 跨进程共享内存

4. 性能剖析工具链

4.1 cargo flamegraph

4.2 perf + cargo-profiler

4.3 tokio-console

5. 编译器优化

5.1 Cargo.toml 优化配置

5.2 PGO（Profile Guided Optimization）

5.3 target-cpu 特定优化

6. Benchmark 实践

6.1 Criterion.rs

6.2 内存分配基准

6.3 Iai（指令计数基准）

7. 内存分析

7.1 dhat（堆分配追踪）

7.2 cargo bloat（查看二进制体积构成）

7.3 cargo audit（依赖安全检查）

8. no_std 系统编程

8.1 自定义分配器

8.2 内核模块编程

Rust 错误处理与测试：thiserror、mockall 与属性测试

目录

1. 错误处理哲学

在Rust中进行原型设计的实践和优势

引言

Rust生成的二进制依赖问题

Tauri介绍

Rust的tikio库介绍

Rust的跨平台特性

Rust的跨平台特性

Rust语言的所有权系统

Cargo.toml文件详细说明

[package] 部分

目标配置

依赖项

特性和配置

配置文件

Rust语言在系统编程方面有哪些优势

Rust语言在系统编程方面有哪些优势

Rust和c++的区别

语言特性对比

Rust

C++

`[package]` 部分