第一阶段 rust基础

rustlings比较顺利，已关注rust好几年了，也一直跟进rust的发展和变化，用了大概几天的时间突击完成

第二阶段 rcore

这是我第一次接触操作系统，印象还都停留在原来的书本上，概念上，都是理论，没有真正接触操作系统是什么样的，所以，这个机会能让我了解探究操作系统内部真正的原理和运行逻辑，解开我心中的多年的疑惑，很是开心到起飞。

总体印象最深的就是操作系统内核是以什么形态存在的，上下文如何切换，进程空间如何形成，页表是如何实现的，跳板页又是怎么回事

第三阶段 ArceOS

这个和我预期不一样，没有沿着rcore继续走，这是一个全新的设计，一时间，有点慌乱，不能和rcore相关的思路很自然的顺承下来，显然这个更具有前瞻性，为此我也花了好多时间来梳理这个逻辑和rcore都关联起来。这个模块化设计的理念很突出，相互之间的关联及细节，需要仔细的研读和体会。

第三阶段的具体case

color

对println!() 把颜色表示直接加入后，可以显示颜色，
如在当前文件写了一个宏print_with_color!，让后让println!去去调用此宏，就得不到正确结果，提示找不到这个宏，查了资料，和 $crate有关，宏的暴露方式有关，引用路径，由于时间关系，后面调研

HashMap

开始的时候，从rust官方移植，这个太痛苦了，依赖太多了，最后放弃。
自己写个简单的，只是利用了官方的
use core::hash::Hasher;
use core::hash::Hash;
这两个hash算法，主体采用了最简单的线性插入算法

bumpallocator

需要仔细理解题意和上下文，思路选用：
申请一直从可用空间起始向前申请，
释放如果全部的空间都释放了，就把下一个可用空间调整到开始

rename

采用递归的方式，一层一层的先找到所在当前目录
增加当前目录的，更改命名的方法，查找相应的文件，删除后，再插入一个，因为当前存储使用的是BtreeMap，不能更改index

hv

这个耗费了我好多时间，主要是因为运行例程会卡住，后来发现可能是qemu的版本问题，升级到9.2后，还是一样卡住，当时环境为windows11，wsl2，卡在这里，不同的情况卡的还不一样：

1

Write file 'payload/skernel2/skernel2' into disk.img

最后没有办法，找一台空闲机器，实在不行，我就安装裸机linux系统，所以先尝试装了另一种虚拟机，virtualbox7.18，也花了些时间，配置好环境后，默认的qemu为6.x时，还是会出错，不过不是卡主的问题，是会触发异常访问，升级到9.2.x后，按照预期执行了，难道说，wsl2在某些情况就是不行，我真是难过。

之后遇到提交github，出错，musl.cc被block，

下载不下来：
wget https://musl.cc/riscv64-linux-musl-cross.tgz

下载不下来，终于等来了替代方案

wget https://musl.cc.timfish.dev/riscv64-linux-musl-cross.tgz
最后，终于得以解决

sys_mmap

参数和返回值我理解出现偏差，

1
2
3
4
5
6
7
8

fn sys_mmap(
    addr: *mut usize,
    length: usize,
    prot: i32,
    flags: i32,
    fd: i32,
    _offset: isize,
) -> isize

参数addr为0时要特别注意，需要寻找一空间，还有地址和size的对齐。返回值，当开始时认为0是成功，为负时，返回失败原因，后来再三确认失败返回0，成功返回地址，isize作为地址返回，有点不符合直觉？

Next

期待第四阶段

前三阶段总结

• 前两阶段总结
• 第三阶段总结

主要收获

在第四阶段中，更多的时间留给了自由探索．虽然起初缺少具体的目标有些令人摸不着头脑，不过跟随老师的引导，也一步步确立了整个阶段的目标：基于 uring^1 机制实现异步系统调用．尽管最后只实现了基于 uring 的异步 IPC 机制，一路上走来也有许多收获．

Rust 的异步机制

虽然有一些 Rust 异步编程经验，但尚未从更底层的角度了解过 Rust 的异步模型．在第一周中，通过动手实现一个简易的异步运行时 local-executor，认识到 Rust 的异步原语 Future 是如何与运行时交互的．以及深入到内存安全层面上，了解了 Rust 中如何通过 pin 语义来巧妙的保证自引用结构体的安全性．尽管这并不是一个完美的模型——几乎所有涉及到 pin 语义的数据结构和函数都需要 unsafe 代码，而这些 unsafe 代码所需的诸多安全性保证又着实有些令人头大．因为，Rust 提供了静态安全性，而编译器会基于这些安全保证进行比较“激进”的优化．所以，Rust 中的 unsafe 要比其他生来便“不安全”的语言更加不安全，对开发者的要求也更高．

在第三周的探索中，又了解到一个之前从未考虑过的问题——Future 的终止安全性^2．而这对于实现基于共享内存的异步通信机制来说尤其关键，稍有不慎就会引发难以察觉的漏洞．在后来着手实现异步通信机制的时候，又对这个问题进行了更深入的思考，并在现有方案的基础上提出了另外几个可行的思路．

原子类型和内存排序

尽管曾了解过原子类型和内存排序相关的知识，但从未真正彻底搞懂过，直到在第二周的探索中发现了一本优秀的电子书 Rust Atomics and Locks^3．这本书从抽象的并发模型深入到具体的硬件细节，比较全面的介绍了几种原子操作和内存排序的设计初衷以及对应的汇编层面实现．结合这本书和自己的思考，又经过悉心整理最终形成了一篇比较详实的学习笔记．尽管在实践时还不能完全掌握各种内存排序的选择，通过翻看笔记以及参考相似场景下现有项目的做法，也都能找到一个安全正确的选项．

基于 uring 的异步通信

经过两周的调查和学习，最终在第三周完成了基于 uring 的异步通信框架 evering，同时利用 GitHub Pages 部署了它详细的设计文档．

evering 最重要的两个数据结构是用来管理消息队列的 Uring 和用来管理操作生命周期的 Driver．Uring 的实现借鉴了 io_uring 的做法^4，但结合 Rust 的特性做了一些简化．比如，io_uring 支持 IOSQE_IO_LINK 来要求响应侧顺序处理请求．而在 Rust 中，每个异步请求都被封装为 Future，故可以利用 .await 来在请求侧实现顺序请求．Driver 的实现则借鉴了 tokio-uring 和 ringbahn．但相比后两者，evering 提供了更灵活、通用的异步操作管理机制．

不过，目前 evering 相对简陋，仅支持 SPSC，因此请求侧或响应侧只能在单线程上使用．也许未来可以实现 MPSC 的队列，以便于更好的与现有的异步生态（比如 tokio）兼容．

基于 evering 的异步 IPC

经过三周的铺垫，第四周正式开始实践跨进程的异步通信．在第三周中，基于 evering 实现了简易的跨线程异步通信 evering-threaded，而对跨进程来说，主要的难点就是内存的共享．好在 Linux 提供了易于使用的共享内存接口，基于 shm_open(3)，memfd_create(2) 和 mmap(2) 可以轻松在不同进程之间建立共享内存区．而 ftruncate(3p) 配合缺页延迟加载机制，使得程序启动后仅需一次初始化就能配置好可用的共享内存区间．不过，目前 evering 只能做到基础的“对拍式”的通信方式．而近期字节跳动开源的 shmipc 则是一个相对成熟、全面的异步通信框架，这对未来 evering 的改进提供了方向．

基于 evering 的异步系统调用

由于时间相对仓促，加之备研要占用大量的时间，遗憾的是，在第四阶段并没有完成最初的目标——实现基于 uring 的异步系统调用．与 用户线程 <-> 用户线程 的通信相比，用户线程 <-> 内核线程 的通信要额外处理内核任务的调度和用户进程的生命周期管理．即如何处理多个不同用户进程的请求，以及用户进程意外退出后对应内核任务的清理．而就共享内存而言，由于用户对内核单向透明，这看起来似乎比 IPC 的共享内存更容易解决．

用户态线程与协程的调度

去年的夏令营中，embassy-preempt 实现了内核中线程和协程的混合调度．那么用户态的协程能否被内核混合调度呢？在实现异步系统调用的前提下，当用户态线程由于内核尚未完成调用处理而让权（通过 sched_yield(2) 等系统调用）时，实际上，内核可以获知该线程应何时被唤醒．这就与 Rust 协程中的 Waker 机制非常相似，而用户态的让权又与 .await 很类似．基于这些，那么可以将一个实现异步系统调用的用户线程转换为一个用户协程．此后，内核就充当了这个协程的运行时和调度器的角色．

而相比用户态的线程，使用协程的一个显著优点是，对用户任务的唤醒实际上相当于执行一次 Future::poll．这意味着，当用户主动让权时，它不需要保存任何上下文——用户任务的唤醒本质上变成了函数调用，而主动让权表示该函数的返回．如此便能够进一步减少用户和内核切换的开销，以及系统中所需执行栈的数量．当然，当用户协程被抢占时，它便回退成了类似线程的有独立执行栈和上下文的存在．

总结

经过近两个月的学习，对操作系统和异步编程的许多方面都有了一些相对清晰的认知．非常感谢夏令营中各位老师的付出和历届同学的努力，学习的过程中让我切身的感受到操作系统发展到现在那段波澜壮阔的历史，以及在不断推陈出新的技术潮流中一点微不足道的参与感．尽管最后没能完成目标有些遗憾，不过，这也为将来再次参加夏令营留下了充足的理由 :P

开源操作系统训练营第四阶段总结 - 低侵入式的异步协程运行时

2025 春夏季开源操作系统训练营 学习总结

1
2
3
4
5

// 实验环境
Mac mini Apple M4
MacOS 15.4.1
// 备注（在国外的同学可以忽略）
在配置实验环境时，一定要更换Homebrew、rustup和Cargo的镜像源。

第一阶段：Rust编程

由于参与过 http://opencamp.cn/ 的其他 Rust 训练营，本阶段相当于是复习阶段。然而笔者对很多 Rust 语法还是理解的不够，需要通过更多实际项目来加深学习。

第二阶段：OS设计实现

本阶段主要参考指导书完成实验 https://learningos.cn/rCore-Tutorial-Guide-2025S/

1. Apple Silicon 相关问题

在第零章，指导书如是说：
经初步测试，使用 M1 芯片的 macOS 也可以运行本实验的框架，即我们的实验对平台的要求不是很高。但我们仍建议同学配置 Ubuntu 环境，以避免未知的环境问题。

笔者在实验中确实遇到了一些问题，但都并非无法解决，具体情况如下：

1.1 安装 qemu (可能需要 sudo)

1
2

brew install qemu
qemu-img --version

如果显示qemu-img version 9.2.3则说明安装成功。

1.2 载入rustsbi-qemu.bin时卡死

@lurenjia1213 修复了该问题，需要 Clone 下面的项目，重新编译，然后拷贝生成的rustsbi-qemu.bin 并覆盖实验项目中的文件。
https://github.com/lurenjia1213/rustsbi-qemu/tree/main

1.3 qemu 模拟器无法正确退出

在ch3中，qemu模拟器无法正确退出，需要拷贝ch2中的./src/boards/qemu.rs到ch3。通过对比ch2和ch3的区别来修复问题，从而可以学习正确退出模拟器的方法。

ch4 通过同样的方法在 BASE=1 的测试中还是无法正确退出，需要以后解决。

1.4 MacOS 没有 timeout 指令导致测例无法通过

安装 coreutils, 用 gtimeout 来替代。

1
2
3

brew install coreutils
// 需要将下面这条指令写到保存环境变量的那个文件中
alias timeout=gtimeout

2. 学习心得

由于没有系统学习过操作系统的理论知识，学的比较慢，需要参考指导书和学习资源中的视频才慢慢掌握。虽然操作系统相关的内容学的不够扎实，但是对于 rust 的语法慢慢熟悉了起来。抱着学习 rust 的心态还学习到了操作系统的底层运行，很有收获。

第三阶段：项目基础阶段 - 组件化操作系统

• 尽管是第一次接触操作系统，在完成第二阶段以后，第三阶段给笔者的感觉不是很陌生（至少知道大概都在干什么）
• 课程视频和课件也很详细的给出了任务和学习目标，但是第三阶段的项目相比第二阶段要大很多
• 有时候不知道要去哪里干什么，只能通过给出的题目反向查找相关的内容。

1.遇到的问题和解决思路

• 在UniKernel部分， 笔者在 MacOS 下面完成了任务，到了宏内核的部分涉及到了交叉编译的部分，似乎 MacOS 变得复杂了起来。折腾了一段时间之后，还是在一台 Linux 服务器上用 docker 完成了后续的任务。
• 这是笔者第一次使用 docker，遇到不懂的就让 Chatgpt 来生成指令，但是还是遇到了很多问题：
  1. hub.docker.com 被墙，根本创建不了 Linux 容器， 后来找到 nvcr.io/nvidia/pytorch:25.05-py3 解决了问题： https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch
  2. 以为 root 之后就万事大吉，但是在运行容器的时候要加上 --privieged， 不然 mount 指令无法正确的找到目录的位置
  3. 运行容器的时候千万不要加 -rm， 不然停止容器的时候就永远地消失了

     2. 学习心得

     由于上述笔者遇到的问题，反反复复搭环境搭了 3 次， 对各种 Linux 指令，以及各种组件的作用有了更深的理解。相比第二阶段，第三阶段的练习难度反而有所下降，但是 ArceOS 本身的内容是相当多的，需要更加系统的学习。 希望能在第四阶段有所收获。

rust基础的总结

一.基本数据类型与所有权

所有权系统核心规则

1. 移动语义(Move)：

   1 2 3

   let s1 = String::from("hello"); // 堆分配 let s2 = s1; // 所有权转移 // println!("{}", s1); // 错误！s1 已失效

2. 借用规则：
   • 任意时刻：一个可变引用 或 多个不可变引用
   • 引用必须始终有效（悬垂指针禁止）
3. 生命周期标注：

   1 2 3

   fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }

Slice 类型

• 无所有权引用：

  1 2 3 4

  let s = String::from("hello world"); let hello: &str = &s[0..5]; // 字符串切片 let a = [1, 2, 3, 4]; let slice: &[i32] = &a[1..3]; // 数组切片

二.Crate 与模块系统

Crate 类型

模块可见性规则

1
2
3
4
5
6
7
8

mod front_of_house {
    pub mod hosting {          // pub 使模块公有
        pub fn add_to_waitlist() {}
    }
}

// 使用绝对路径访问
crate::front_of_house::hosting::add_to_waitlist();

使用外部 Crate

1
2
3

# Cargo.toml
[dependencies]
rand = "0.8.5"  # 语义化版本

1
2
3
4
5
6

// main.rs
use rand::Rng;

fn main() {
    let num = rand::thread_rng().gen_range(1..101);
}

三. Option 与错误处理

Option 枚举

1
2
3
4
5
6
7
8
9
10
11

enum Option<T> {
    Some(T),
    None,
}

// 安全解包
let x: Option<i32> = Some(5);
match x {
    Some(i) => println!("Value: {}", i),
    None => println!("Missing value"),
}

Result<T, E> 错误处理

1
2
3
4
5
6
7
8
9
10
11

fn read_file(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

// 错误传播简写
fn read_config() -> Result<String, io::Error> {
    let mut file = File::open("config.toml")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

错误处理最佳实践

1. 优先使用 Result 而非 panic
2. 使用 ? 操作符传播错误
3. 自定义错误类型实现 std::error::Error

四. Trait 与泛型

Trait 定义与实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14

trait Summary {
    fn summarize(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{} ({})", self.headline, self.location)
    }
}

泛型函数

1
2
3
4
5
6
7
8
9

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

Trait Bound 语法糖

1
2
3

// 以下两种写法等价
fn notify<T: Display + Clone>(item: &T) {...}
fn notify(item: &(impl Display + Clone)) {...}

生命周期进阶

生命周期标注必要性：

1. 结构体持有引用时必须显式标注生命周期，确保引用的有效性
2. 方法实现中：
   • &self 参数隐含 &'a self 生命周期
   • 返回值关联结构体生命周期（通过生命周期消除规则第三项）
3. 遵循Rust生命周期消除三规则：
   • 每个输入引用自动获得独立生命周期
   • 单个输入引用时所有输出引用与其生命周期对齐
   • 方法签名中 &self 使输出引用与结构体生命周期对齐

错误：

1
2
3
4

fn dangling_reference() -> &str {
    let s = String::from("temporary");
    &s[..]  // 错误！返回局部变量引用
} // s离开作用域被丢弃

1
2
3
4
5
6
7
8
9
10

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

五. 智能指针

常用智能指针对比

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Box 用于递归类型
enum List {
    Cons(i32, Box<List>),
    Nil,
}

// Rc 共享所有权
use std::rc::Rc;
let a = Rc::new(5);
let b = Rc::clone(&a);

// RefCell 运行时借用检查
use std::cell::RefCell;
let c = RefCell::new(42);
*c.borrow_mut() += 10;

六.迭代器与闭包

闭包类型推断

1
2

let add_one = |x| x + 1;         // 类型自动推导
let print = || println!("hello"); // 无参闭包

闭包捕获模式

迭代器适配器

1
2
3
4
5
6
7

let v = vec![1, 2, 3, 4];

// 链式调用
let sum: i32 = v.iter()
    .map(|x| x * 2)        // 加倍
    .filter(|x| x % 4 == 0) // 过滤4的倍数
    .sum();                 // 求和

自定义迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

七.并发与异步编程

线程创建

1
2
3
4
5
6
7

use std::thread;

let handle = thread::spawn(|| {
    println!("From spawned thread");
});

handle.join().unwrap();

通道通信 (mpsc)

1
2
3
4
5
6
7
8
9

use std::sync::mpsc;

let (tx, rx) = mpsc::channel();

thread::spawn(move || {
    tx.send("Message").unwrap();
});

println!("Received: {}", rx.recv().unwrap());

共享状态 (Mutex)

1
2
3
4
5
6
7
8
9
10
11

use std::sync::{Arc, Mutex};

let counter = Arc::new(Mutex::new(0));

let handles: Vec<_> = (0..10).map(|_| {
    let c = Arc::clone(&counter);
    thread::spawn(move || {
        let mut num = c.lock().unwrap();
        *num += 1;
    })
}).collect();

异步编程 (async/await)

1
2
3
4
5
6
7
8
9
10
11
12

async fn fetch_data() -> Result<String, reqwest::Error> {
    reqwest::get("https://api.example.com/data")
        .await?
        .text()
        .await
}

#[tokio::main]
async fn main() {
    let data = fetch_data().await.unwrap();
    println!("Data: {}", data);
}

八.常用集合类型

Vec 动态数组

1
2
3
4
5
6
7
8
9
10
11

let mut v = Vec::with_capacity(10);
v.extend([1, 2, 3]);

// 安全访问
if let Some(val) = v.get(1) {
    println!("Second element: {}", val);
}

// 所有权注意事项
let first = &v[0];
// v.push(4); // 编译错误！存在不可变引用时禁止修改

HashMap<K, V> 哈希表

1
2
3
4
5
6
7
8

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert("Blue", 10);

// Entry API 安全更新
scores.entry("Yellow").or_insert(50);
scores.entry("Blue").and_modify(|e| *e += 1);

阶段二,os基础

lab1

与上下文, 特权级有关的寄存器

• sstatus：包含了处理器的状态信息，包括特权级别和中断使能状态。恢复 sstatus 的值确保在返回用户态时，处理器的特权级别和中断状态与陷阱发生前一致。
• sepc：保存了中断或异常发生时的程序计数器值。恢复 sepc 的值确保在返回用户态时，处理器能够从中断或异常发生的地方继续执行。
• sscratch：保存了用户栈指针。在切换到用户态之前，将用户栈指针保存到 sscratch 寄存器中，以便在用户态下使用。
• sret根据sstatus中的SPP位指示切换为用户态。（寄存器中的一个位，0,u_mode;1_,s_mode,s_mode）
• scause: Trap原因/种类
• stvec: trap_handle地址

lab2

SV39

• virtual page 39位, 38-12为虚拟页号
• 页表项PTE: Reserver: 10, PPN2: 26, PPN1: 9, PPN0: 9, RSW: 2, DAGUXWRV

分页

• MMU地址转换
• kernel address space最高位为 “跳板”, app ks, guard page
• app address space, 最高位为跳板, TrapContext, UserStack, GP, Framed

  跳板意义:

  satp, 切换后,地址映射不同, 例如:上下文切换的restore, 在更改satp指令后, 保证下一条指令在不同的地址映射下能被正确寻址,保证指令的连续执行

TrapContext新增字段

在进行特权级转换时, 需要相应的sp以及satp的token

• pub kernel_satp: usize, 内核地址空间的 token
• pub kernel_sp: usize, 当前应用在内核地址空间中的内核栈栈顶的虚拟地址
• pub trap_handler: usize, 内核中 trap handler 入口点的虚拟地址

lab3

fork

• 获得父进程的地址空间
• sepc + 4
• a0返回参数更改,父子进程不相同
• 维护父子进程关系
• fd, 死锁检测等

功能实现

• stride算法:

  • 为TCB加上schedule块(struct), 同时预留了pass设置的接口
  • 为sys_set_priority加入了对priority的设置
  • 将TaskManager块改为了用binaryheap存储, 并为TCB分配了Ord特性,每次选取都会取stride最小的调度

• 向前兼容

  • 重写mmap和munmap(用到了remove_area_with_start_vpn)
  • 重写了sys_get_time,用到了translate_va

lab4

文件系统

文件系统本质上是一堆块上的抽象, 在内存中有缓存块对其进行映射.

进程维护一个文件描述符表,可映射到对应的缓存块

1
2
3
4
5
6
7
8

pub struct BlockCache {
    cache: [u8; BLOCK_SZ],
    block_id: usize,
    block_device: Arc<dyn BlockDevice>,
    modified: bool,
}

//提供对应的接口调用

easy-fs磁盘布局

• 超级块 (Super Block)，用于定位其他连续区域的位置，检查文件系统合法性。

• 索引节点位图，长度为若干个块。它记录了索引节点区域中有哪些索引节点已经被分配出去使用了。

• 索引节点区域，长度为若干个块。其中的每个块都存储了若干个索引节点。

  1 2 3 4 5 6 7 8

  #[repr(C)] pub struct DiskInode { pub size: u32, pub direct: [u32; INODE_DIRECT_COUNT], pub indirect1: u32, pub indirect2: u32, type_: DiskInodeType, }

• 数据块位图，长度为若干个块。它记录了后面的数据块区域中有哪些已经被分配出去使用了。

• 数据块区域，其中的每个被分配出去的块保存了文件或目录的具体内容。

lab5

在引入线程后, 调度机制本质上是在线程块上进行切换. 会区分主线程和子线程

• 创建线程不需要要建立新的地址空间
• 能够访问到进程所拥有的代码段， 堆和其他数据段
• 专有的用户态栈

实现功能

• 在ProcessControlBlockInner加入了对mutex和sem的死锁检查块(all[], ava[], need[])
• 检测前对相应资源的need[] + 1
• 实现is_safe检测函数, 对finish==false和need <= work的块, 回收allocation和finish=true,对标记flag=true, 当finish没有任何改变, 即本次循环flag==false时退出loop, 利用闭包all,检测finish所有线程是否全是true
• 若为unsafe, 则回退need, 返回-0xdead
• 若为safe, 则在down和lock之前drop(process_inner),防止线程堵塞无法释放资源, 在down和lock之后同时更新检查块中的矩阵
• 为up和unlock加上检查块的更新

Mutex实现问题

• Mutex1的lock里,会一直尝试获取锁, 具体逻辑为当无法获得锁时,直接阻塞,让出cpu,直到被唤醒, 再重新尝试获得锁, unlock中释放锁,并且唤醒一个线程去竞争这个锁.
• Mutex的lock,在无法获得锁时,直接堵塞,在unlock时,只有等待队列为空才释放锁.

  - 这里的unlock本质是锁资源的转移, A不释放锁, 而是唤醒一个直接使用这个资源的B线程(它醒来后直接运行临界区后的代码)

第三阶段

一, 组件化内核基础与 Unikernel 模式

组件化内核介绍

Unikernel 模式

• 特点：
  • 应用与内核合一：编译为一个 Image，共享同一特权级（内核态）和地址空间。
  • 无用户态 / 内核态切换：简单高效，但安全性较低（应用可直接访问内核资源）。

核心组件

Unikernel 的启动链

• 硬件启动：通过 OpenSBI（Riscv 固件）加载内核 Image 到内存。
• 引导阶段（axhal）：
  • 初始化 CPU 寄存器、MMU 分页（早期恒等映射）。
  • 建立内核栈，为 Rust 运行时做准备。
• 运行时阶段（axruntime）：
  • 初始化内存分配器、日志系统。
  • 调用应用层 main 函数，执行具体功能。

实验

1. 主函数 src/main.rs

1
2
3
4
5
6
7
8

#![cfg_attr(feature = "axstd", no_main)] // 若启用 axstd，不使用标准库的 main 入口
#[cfg(feature = "axstd")] // 根据 feature 条件编译
use axstd::println; // 使用 axstd 的打印函数

#[cfg_attr(feature = "axstd", no_mangle)] // 避免符号名被修改
fn main() {
    println!("Hello, ArceOS!"); // 调用 axhal 提供的串口输出功能
}

2. 依赖管理 Cargo.toml

1
2
3

[dependencies]
axstd = { workspace = true } // 引入 axstd 组件，支持标准库功能
arceos_api = { workspace = true } // 引入内核公共接口

3. features 动态配置

• 作用：通过编译参数控制组件的启用，实现 “按需构建”。
• 示例：
  • axstd 组件通过 feature = “axstd” 控制是否包含。
  • 实验中默认启用 axstd，因此能使用 println!。

println!

通过更改ulib下axstd,macros文件中的println!

hashmap

1
2

#[cfg(feature = "alloc")]
pub mod collections;

暴露自己写的collections

1
2
3

[dependencies.hashbrown]
version = "0.14"
default-features = false

用了官方库的core版本

二, 内存管理与多任务基础

1. 分页的两个阶段

2. 算法

3.

全局分配器：通过 #[global_allocator] 声明，实现 GlobalAlloc trait。

1
2

#[cfg_attr(all(target_os = "none", not(test)), global_allocator)]
static GLOBAL_ALLOCATOR: GlobalAllocator = GlobalAllocator::new();

任务数据结构 TaskInner

1
2
3
4
5
6
7
8

struct TaskInner {
    id: TaskId,           // 唯一标识
    name: String,         // 任务名称（调试用）
    state: AtomicU8,      // 状态（Running/Ready/Blocked/Exited）
    kstack: Option<TaskStack>, // 任务栈（类似线程栈）
    ctx: UnsafeCell<TaskContext>, // 上下文（保存寄存器状态）
    // 其他字段：调度相关（如时间片、优先级）
}

协作式调度

FIFO 队列：任务按 “先到先服务” 原则执行，当前任务需主动让出 CPU（调用 yield_now()）。

组件

实现

EarlyAllocator实现要求比较低

byte

• alloc
  • 注意每次分配内存时候的对齐
  • 预分配，检查是否与p_pos重叠
  • 为count++
    • 注意每次分配内存时候的对齐
    • 预分配,检查是否与p_pos重叠
    • 为count++
• dealloc
  • 单纯的count–
  • count==0时,就可以重置b_pos了

page

• alloc
  • 检查alignment是否有效
  • 获取分配的size进行对齐，同时检查是否越界
  • 更新数据
    • 检查alignment是否有效
    • 获取分配的size进行对齐,同时检查是否越界
    • 更新数据
• dealloc
  • 不要求实现

三、调度,块设备,文件系统

时钟中断：

代码（Riscv64 中断初始化）

1
2
3
4
5
6

// axhal/src/platform/riscv64_qemu_virt/mod.rs
axhal::irq::register_handler(TIMER_IRQ_NUM, || {
    update_timer(); // 更新系统时间
    axtask::on_timer_tick(); // 触发调度器更新
});
axhal::arch::enable_irqs(); // 开中断

块设备驱动：

Trait：BlockDriverOps

1
2
3
4
5

trait BlockDriverOps {
    fn num_blocks(&self) -> u64; // 磁盘总块数
    fn block_size(&self) -> usize; // 块大小（512 字节）
    fn read_block(&mut self, block_id: u64, buf: &mut [u8]) -> DevResult; // 读块
}

文件系统：

抽象

文件系统（FileSystem）：如 FAT32、EXT4。

目录（Dir）：存储文件 / 子目录元数据。

文件（File）：存储具体数据，支持读写操作。

接口

1
2
3
4

trait VfsOps {
    fn root_dir(&self) -> &DirNode; // 获取根目录
    fn lookup(&self, path: &str) -> Option<FileNode>; // 解析路径
}

加载流程

块设备读取：通过 VirtIO Blk 驱动读取磁盘前 512 字节（引导扇区）。

解析 BPB：获取 FAT 表起始地址、簇大小等参数。

挂载文件系统：将 FAT32 的根目录挂载到 VFS 的 / 节点。

应用加载示例（U.8 实验）

1
2
3
4
5
6

// 从 FAT32 文件系统加载应用程序
fn load_app(path: &str) -> Result<Vec<u8>> {
    let root = vfs.root_dir();
    let file = root.lookup(path).ok_or("文件不存在")?;
    file.read_to_end() // 读取文件内容到内存
}

实验实现

寻找ing

在axfs_ramf中实现

1

impl VfsNodeOps for DirNode{...}

文件时通过封装的BTreeMap管理的, 替换相应键值对即可

注意

1

fn rename(&self, src_path: &str, dst_path: &str)

src和dst_path路径层级不一样
我使用了split_path_to_end来获取最终的文件名

四, 地址空间管理

缺页异常处理

1
2

// 关键修改：init_user_stack的lazy参数设为false
let ustack_top = init_user_stack(&mut uspace, false).unwrap(); // 延迟映射

缺页异常处理流程

• 异常触发：用户态访问未映射地址（如栈写入），CPU 陷入内核。
• 处理逻辑：
  1. 通过handle_page_fault函数申请物理页帧（alloc_frame）
  2. 在页表中建立虚拟地址与物理页帧的映射（pt.remap）

1
2
3
4
5

fn handle_page_fault(...) -> bool {
    let frame = alloc_frame(true); // 申请物理页
    pt.remap(vaddr, frame, orig_flags); // 建立映射
    tlb.flush(); // 刷新TLB
}

ELF 格式解析

关键段：
LOAD 段：包含代码段（R E标志）和数据段（RW标志）。
BSS 段：未初始化数据，ELF 文件不存储，内核需预留空间并清零。
加载逻辑：

1
2
3
4
5
6
7
8
9
10
11
12

for segment in elf.segments {
    if segment.type == LOAD {
        let vaddr = segment.virt_addr;
        let phys_frame = alloc_frame(segment.mem_siz);
        map_virtual_to_physical(vaddr, phys_frame, segment.flags);
        if segment.has_data {
            copy_file_data(vaddr, segment.file_offset, segment.file_siz);
        } else {
            zero_memory(vaddr, segment.mem_siz); // BSS段清零
        }
    }
}

实验实现

得到aspace->分配内存->将文件信息写入

1
2
3
4
5
6

const MAP_SHARED = 1 << 0;    // 共享映射，对映射区域的修改会反映到文件中
const MAP_PRIVATE = 1 << 1;   // 私有映射，对映射区域的修改不会反映到文件中
const MAP_FIXED = 1 << 4;     // 必须使用指定的映射地址
const MAP_ANONYMOUS = 1 << 5; // 匿名映射，不与文件关联
const MAP_NORESERVE = 1 << 14; // 不保留交换空间
const MAP_STACK = 0x20000;    // 用于栈分配

这里只处理MAP_PRIVATE,
同时addr.is_null(),可通过aspace.find_free_area寻找内存

五, Hypervisor

Hypervisor

1.1 定义

Hypervisor（虚拟机监控器）是运行在物理硬件与虚拟机之间的虚拟化层软件，允许多个虚拟机共享物理资源，每个虚拟机拥有独立的虚拟硬件环境（如vCPU、vMem、vDevice）。

1.2 核心功能

• 资源虚拟化：模拟CPU、内存、设备等硬件资源
• 隔离与调度：确保虚拟机之间资源隔离，并高效调度物理资源
• 模式切换：在Host（Hypervisor）与Guest（虚拟机）之间双向切换

1.3 与模拟器的区别

1.4 虚拟化类型

1. I型Hypervisor：直接运行在硬件上（如Xen、KVM），性能高
2. II型Hypervisor：运行在宿主OS上（如VirtualBox），依赖宿主资源管理

二. Riscv64虚拟化扩展（H扩展）

2.1 特权级扩展

新增特权级：

• HS(Hypervisor Supervisor)：Host域的管理级，负责虚拟化控制
• VS(Virtual Supervisor)：Guest域的内核级，运行Guest OS内核
• VU(Virtual User)：Guest域的用户级，运行Guest应用

特权级关系：

1
2

物理机：M（最高） > HS > U
虚拟机：VS（Guest内核） > VU（Guest用户）

2.2 关键寄存器

• hstatus：控制Host与Guest的模式切换
  • SPV位：指示进入HS前的模式（0：非虚拟化模式；1：来自Guest的VS模式）
  • SPVP位：控制HS是否有权限操作Guest的地址空间
• vs[xxx]/hs[xxx]：分别用于Guest和Host的上下文管理
• misa：标识是否支持H扩展（bit7=1表示支持）

3. 模式切换机制

3.1 从Host到Guest（run_guest函数）

1
2
3
4
5
6

// 保存Host寄存器状态
sd ra, (hyp_ra)(a0)  // 保存返回地址
// 加载Guest寄存器状态
ld sstatus, guest_sstatus(a0)
// 执行sret指令切换到VS模式
sret

可参考guest.s

• a0指向的guest_reg区域 与 当前reg的替换

  3.2 VM-Exit处理（以SBI调用为例）

  1 2 3 4 5 6 7 8 9

  match scause.cause() { Trap::Exception(Exception::VirtualSupervisorEnvCall) => { let sbi_msg = SbiMessage::from_regs(ctx.guest_regs.gpr); if let Some(SbiMessage::Reset(Shutdown)) = sbi_msg { ax_println!("Shutdown vm normally!"); // 清理Guest资源 } } }

实现

根据结果硬编码,更改guest_reg的值

Stage 1

这个阶段主要是学习Rust语法，因为之前有报名过训练营，所以做起来比较顺手，把基础语法又复习了一遍。

Stage 2

这个阶段主要是阅读实验指导书和源码。实验指导书非常重要，如果没有看明白的话对做实验有很大影响，所以要细心耐心看。时间有限的话，看精简版指导书即可。
完成实验部分需要重点理解几个点：

1. 任务切换机制，保存切换前后程序上下文
2. 地址空间，多级页表机制
3. 文件系统，操作与管理

Stage 3

这个阶段主要是看视频和PPT，并通过做6个实验来熟悉ArceOS的设计思想。相对于上一个阶段的实验会简单一些。

总结

之前有报名过两次训练营，但都没有坚持下来。对于如何平衡学习、工作和自我提升之间的平衡，是一个我现在以及将来都需要仔细思考的问题。

Prologue

这样的总结应该从何开始？我是从Bilibili刷视频偶然了解到与训练营相关的信息的。使用Rust语言编写操作系统的实践，我太喜欢这个方向了。因为我正学过一点Rust，也经学校老师的推荐看过CSAPP并完成了大多数的实验。其中我最喜欢的便是shlab和attacklab────写一个shell！实在是有趣不过，如果再写一个操作系统呢？好吧，我应该没有与之匹配的实力，不过开源操作系统训练营就这样给了我一个类似的机会。报名人数破千！全程免费！还有什么好说的呢，杀😡。

Stage 1

110道Rustling编程题，并没有耗费我太多功夫，更多的是重新熟悉一下语法。我觉得，学习Rust不仅是学会如何使用一门编程语言，更是了解更多的编程范式。例如trait背后的组合大于继承；函数式编程对现代编程语言深刻的影响：默认不可变、闭包、HOFs、链式操作等；所有权与生命周期机制，这种RAII思想是C++首创的（但是opt-out）。Rust编译器就是你最好的老师，更别说还有满地走的各式AI（本总结经AI辅助完成），2025年的今天，学习Rust不应该再是一件难事🥳。

Stage 2

到了OS设计实现，主要是完成5道rCore操作系统大实验编程题。我是提前进入该阶段，所以全程并没有看过相关学习视频，而是跟随rCore-Tutorial-Guide文档完成的🤓。

这阶段最耗时的是lab2───地址空间和lab5───并发，这两个不管哪个太痛苦了😭。lab2是因为分页机制本身就相对复杂，层层抽象，读内核新增的代码就花了我很久时间（光论这一点文件系统其实不遑多让，不过到这里我的读代码能力已经得到显著锻炼了，所以带给我的痛苦远不及地址空间🥱）。而lab5，单纯是我因为技术路线的左右互博而无限拖缓了进度，我一直在对死锁检测资源的获取上究竟是现场构建还是跟随进程保存之间反复横跳。倒不如说，是因为我在实现这两个的时候遭遇多方掣肘，导致我不停怀疑我自己，不停的重构。使用Rust编程不就是戴着脚镣在跳舞吗？我现在水平还不够，只能写出不够优美的实现，但是我不会放弃的😡。

Stage 3

组件化操作系统，这大概是最各显神通的阶段了。我对这阶段的印象其实是一点草台味🤯，遇到各方面奇怪的问题，测试脚本死活不通过，各种不同的资料，到底要实现在哪里，我要怎么修改一个crate依赖的代码？我是个不撞南墙不愿意问别人的人，所以我全部都闭门造车自己解决了所有问题（真的吗？至少测例说我通过了）。但实际上，在讨论群里大家都很乐意回答别人的提问，每个人都有自己的“奇技淫巧”，应该让大家全都热烈讨论遇到的问题，才能让训练营变得更好😈。

Conclusion

写到这里我已经有点精疲力竭。我在参与前三个阶段的过程中收获颇多，不只是对整个组件化操作系统的认识。还有各种在学习过程中对工具的使用，helix、Zellij，这些工具，我很早就下载了，只是因为它是Rust重写的老工具。现在呢？我需要helix丰富的快捷键，我需要Zellij的分屏。我开始熟悉，正是我开始迈出一步，参加了这次，2025 春夏季开源操作系统训练营。

完成了三阶段的任务，我也疲惫了，进入了一种拖延的状态。五月二十二号，新建文件夹，想要完成这篇总结报告。一直到今天，我终于又想重新出发了。希望到了第四阶段，我可以找到新的方向。

编程的乐趣：⭐️⭐️⭐️⭐️
挑战的难度：⭐️⭐️⭐️
开源训练营：⭐️⭐️⭐️⭐️⭐️

RUST学习总结

函数：

• 函数名和变量名使用蛇形命名法(snake case)，例如 fn add_two() -> {}
• 函数的位置可以随便放，Rust 不关心我们在哪里定义了函数，只要有定义即可
• 每个函数参数都需要标注类型

所有权

基础类型：不会转移所有权，属于复制变量的值

复合类型：会转移所有权，相当于重新绑定变量

（深拷贝：复合类型变量名.clone()，不转移所有权）

引用

• 以&表示引用，以*表示解引用
• 可变引用首先要求变量可变，引用时也要写成&mut 变量名，否则是可变变量的不可变引用
• 一个变量的可变引用同时只能存在一个，可变与不可变引用不可同时存在
• “同时”指引用的作用域，为引用”从创建开始，一直持续到它最后一次使用的地方“

复合类型

字符串

切片：对string类型中某一部分的引用，即&变量名[开始……终止]，切片类型为&str

string与&str的转化：

&str化成string: String::from("字符串字面量")/"字符串字面量".to_string()

string化成&str: 取切片

操作字符串（针对于string）

• 追加：push(字符)/push_str(字符串字面量（不能是string类型）) 改变原有的字符串（不返回新值，必须mut可变）
• 插入：insert()/insert_str() 需要传入两个参数，第一个是插入位置索引，第二个是插入内容 改变原有字符串
• 替换：replace(被替换的字符串，新的字符串) 返回新的字符串（需要新变量接收）

1
2

let string_replace = String::from("I like rust. Learning rust is my favorite!");
let new_string_replace = string_replace.replace("rust", "RUST");

replacen(被替换的字符串，新的字符串，替换的个数) 返回新的字符串

replace_range(要替换的范围，新的字符串) 改变原有的字符串

• 删除：pop() 删除并返回最后一个字符 改变原有的字符串

  remove(字符起始索引) 删除并返回指定位置的字符 改变原有的字符串

  truncate(字符起始索引) 删除指定位置至结尾的所有字符 改变原有字符串

  clear() 清空字符串

• 连接：+/+= 相当于调用函数add(self, s:&str……) 第一个参数是string,其所有权会被转移，后面的参数需要&str类型 '+'返回新的字符串

  format!("{}", s) 用法与println!类似， 返回新的字符串

注：此处所有涉及索引的方法（包括切片），都是以字节为单位处理数据；对于UTF-8类型字符非常容易出错

结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1、// 定义字段
struct 结构体名称 {
    字段名称1： 类型 //结构体字段
}
gree
2、// 初始化：每个字段都要初始化，但顺序不一定一样
let 变量名 =  结构体名称 {
    字段名称1： 值 
}
let 变量名 =  结构体名称 {
    字段名称1： 值 
    ..另一个同类型变量2名的名称	//	剩余自动从另一变量中获取（该语句必须位于尾部）
    				//	同时变量2部分字段会发生所有权转移
}

3、// 访问字段
变量名.字段名	

4、// 元组结构体、单元结构体
let a : (i32, f64, u8) = (500, 6.4, 1); // (i32, f64, u8)是元组
struct Color(i32, i32, i32); // 元组结构体，适用于结构体有名称，字段没有的情况
struct AlwaysEqual; // 单元结构体，没有属性与字段

5、 // 结构体数据所有权：字段值最好不要基于引用，否则需要加上生命周期

6、 // 正常情况无法{}打印，需要在开头加上#[derive(Debug)]，使用{:?}或{:#?}来打印

枚举

枚举类型是一个类型，它会包含所有可能的枚举成员，而枚举值是该类型中的具体某个成员的实例

1
2
3
4
5
6
7
8

// 枚举变体携带数据
enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(char),
    Hearts(char),
} // 任何类型的数据都可以放入枚举成员中，包括另一个枚举或者结构体
let c1 = PokerCard::Spades(5);

数组

分为静态的array和动态数组vector，先看array

array可以正常使用下标访问，可以使用{:?}打印

1
2
3
4
5
6

let a = [1, 2, 3, 4, 5]; // 定义
let a: [i32; 5] = [1, 2, 3, 4, 5]; // 需要声明类型时
let a = [3; 5]; // 某个值重复出现
let arrays: [[u8; 3]; 4]  = [one, two, blank1, blank2]; // 二维数组

let slice: &[i32] = &a[1..3]; // 数组切片

流程控制

if: if语句块是表达式，可以有返回值

for

1
2
3
4
5
6
7
8
9
10
11
12

for 元素 in 集合/0..集合.len() { // 注意，此处集合需要使用引用，否则所有权会被转移（如需更改加上mut）
}

// 想要获取元素的索引
let a = [4, 3, 2, 1];
for (i, v) in a.iter().enumerate() {
    println!("第{}个元素是{}", i + 1, v); // .iter()方法把 `a` 数组变成一个迭代器
}

// 只在意循环次数
for _ in 0..10 {
}

continue与break依然存在

while

1

while 条件 {}

loop

无条件循环，必须搭配break

（break类似于return，可以单独使用也可以带回来一个返回值；

loop同样是表达式，可以返回一个值）

模式匹配

match和if let

match: 非常类似于switch(但匹配后只会执行当前分支，而不会往下”贯穿“)

match同样是表达式，可以有返回值

1
2
3
4
5
6
7
8
9
10

match target {
    模式1 => 表达式1, // =>代替了:
    模式2 | 模式3 => {	// X|Y
        语句1;
        语句2;
        表达式2 // 注意，语句同样可以返回()
    },
    _ => 表达式3 // _代替了default，必须穷尽所有情况否则会报错
    //或者 任意无关变量名 => 表达式3  // 此时就可以对该变量操作，不操作记得使用_开头
}

模式绑定（从匹配到的分支中取出绑定的值）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState), // 25美分硬币
}
match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state); // 可以取出绑定的具体state值
            25
        },
    }

if let: 适用于只需要判断一个模式是否匹配的情况,比if更适用于匹配

1
2
3
4

let some_value = Some(5);
if let Some(v) = some_value {
    println!("Value is: {}", v);
}

while let: while和let的总和，即如果满足条件就可循环，同样可以从模式匹配中拆出值

注：match/if let/while let都会转移被匹配值的借用值的所有权，需要使用ref抵消（ref只在左侧生效）

1
2
3

if let Some(ref x) = value
match opt {
    Some(ref s) => println!("Got a reference to string: {}", s),

Option<T>

表示一个值是否存在的枚举(Some<T>与T不是同一类型)

对于Some和None可以不加Option::前缀

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

enum Option<T> {
    Some(T),  // 表示有值
    None,     // 表示无值
}

//存储
let x: Option<i32> = Some(42);  // Some(42) 代表 x 里面存了 42
let y: Option<i32> = None;      // None 代表没有值

//解构
match x {
    Some(v) => println!("Value is: {}", v),  // 取出 v
    None => println!("No value"),
}
if let Some(v) = x {
    println!("Value is: {}", v);
}

方法

impl中存储方法与struct中声明字段分开，同时一个结构体可以有多个impl块

1
2
3
4
5
6
7
8
9
10

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
} // &self代替了self:&Self

注：

• self 表示 Rectangle 的所有权转移到该方法中，这种形式用的较少

  &self 表示该方法对 Rectangle 的不可变借用

  &mut self 表示可变借用

• 允许方法名和字段名相同

• 在调用方法时只有.没有->

• 枚举同样可以定义方法

关联函数

定义在结构体impl且没有self的函数

不能使用变量.函数()的方法调用，只能使用结构体名称::函数名(参数)来调用

比如String::from()

泛型

为了抽象不同的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn 函数名<T>(变量名: T) -> T { // 函数泛型
struct Point<T> {
    x: T,
    y: T,
} // 结构体泛型，多个类型也可以声明如struct Point<T,U>
enum Result<T, E> {
    Ok(T),
    Err(E),
} // 枚举泛型，可以根据返回值的类型判断是否成功
struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> { 
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
} // 结构体泛型，impl处需要另外声明，impl中的方法可以拥有自己的泛型
  //对于结构体泛型，还可以为特定的泛型单独声明方法

• 在使用T前需要先声明<T>，T的名字可以随便取
• 有时在调用泛型函数时需使用函数名::<具体类型>()来显式指定T的类型

const泛型

允许常量值成为泛型变量，语法为const N: usize，表示const泛型N，它的值基于usize

1
2
3

struct Buffer<T, const N: usize> {
    data: [T; N], // N 作为数组大小
}

const fn: 在函数声明前加上const关键字

注：const泛型与const fn都需要在编译时确定，const fn就可以用于给const泛型赋值

特征

定义了一组可以被共享的行为，只要实现了特征，你就能使用这组行为（类似于接口）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

pub trait Summary {
    fn summarize(&self) -> String; // 只是一个抽象接口，而不具体实现
} // 定义特征

// 为每个需要的类单独实现特征
impl Summary for Post {
    fn summarize(&self) -> String {
        format!("文章{}, 作者是{}", self.title, self.author)
    }
}
impl Summary for Weibo {
    fn summarize(&self) -> String {
        format!("{}发表了微博{}", self.username, self.content)
    }
}

注：

• 孤儿规则：如果你想要为类型 A 实现特征 T，那么 A 或者 T 至少有一个是在当前作用域中定义的（另一个可以在其他库中引入）
• 默认实现：可以在特征中定义具有默认实现的方法，这样其它类型无需再实现该方法，或者也可以选择重载该方法（默认实现允许调用特征中其他方法，哪怕这个方法没有默认实现）

特征约束

特征作为函数参数：

1
2
3

pub fn notify(item: &impl Summary) { // 实现了Summary特征 的 item 参数
    println!("Breaking news! {}", item.summarize());
}

语法：

1
2
3
4
5
6

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}
// 对于结构体方法
impl<T: Display> ToString for T {
}

形如 T: Summary 被称为特征约束

多重约束:

1
2
3

// 要求同时实现了两个特征的参数
pub fn notify(item: &(impl Summary + Display)) {}
pub fn notify<T: Summary + Display>(item: &T) {}

where约束

1
2
3
4
5

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}
fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{}

函数返回值：

通过 impl Trait 来说明一个函数返回了一个类型，该类型实现了某个特征

1

fn returns_summarizable() -> impl Summary { // 返回一个实现了Summary特征的类型

特征对象

允许你使用 不同类型 但 实现了相同特征 的对象，使它们可以在 同一个变量、参数或返回值 中使用

1
2
3
4
5
6

// 语法
&dyn 特征名 // 必须要使用指针，否则无法确定大小
Box<dyn 特征名> // 智能指针

// 动态数组
Vec<Box<dyn 特征名>>

集合类型

动态数组Vector

使用Vec<T>表示，只能存储相同类型的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 创建数组
let v: Vec<i32> = Vec::new();
let mut v = Vec::new(); // 在添加元素后会自动推导
let mut v: Vec<i32> = Vec::with_capacity(5); // 预先分配空间

let v = vec![1, 2, 3]; // 宏vec!可以给予初始值
let v = vec![0; 3];   // 默认值为 0，初始长度为 3
let v_from = Vec::from([0, 0, 0]);

// 更新（需要为mut）
v.push(n); // 可变引用，不能与其他引用同时存在

// 访问元素
v[下标] //		越界不会检查
v.get(下标) // 返回Option<T>,需要match来解构出值		确保不会越界

// 遍历
for i in &(mut) v {}
    
// 常见方法
v.is_empty()
v.insert(pos, val) // 在指定索引pos处插入数值val
v.remove(pos) // 删除在pos处的数并返回该数
v.pop() // 删除尾部的数并返回(返回的是Option<T>的枚举值)
v.clear()
v.append(&mut v1) // v1所有数据全部转入v，v1被清空

// 排序
sort/sort_unstable() // 默认按照升序类型，且要元素可比较
sort_by/sort_unstable_by(闭包实现) // 可以自定义比较规则来实现多种类型的比较

注：可以通过使用枚举类型和特征对象来实现不同类型元素的存储

KV存储HashMap

需要使用use std::collections::HashMap;来引入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 创建与插入
let mut my_gems = HashMap::new();
my_gems.insert("红宝石", 1);

HashMap::with_capacity(capacity)

let teams_list = vec![
        ("中国队".to_string(), 100),
        ("美国队".to_string(), 10),
        ("日本队".to_string(), 50),
    ];
let teams_map: HashMap<_,_> = teams_list.into_iter().collect(); // 从动态数组转化为hashmap

// 在表中查询元素
let score: Option<&value类型> = 表名.get(key的引用); // 注意返回的是Option<T>类型

// 遍历
for (key, value) in &表名 {
    println!("{}: {}", key, value);
}

// 更新表中的值
let old = scores.insert("Blue", 20); // 会直接覆盖旧值，返回Some(旧值)/None
let v = scores.entry("Yellow").or_insert(5); // 查询Yellow对应的值，若不存在则插入新值；返回存储值的可变引用

注

HashMap 的所有权规则与其它 Rust 类型没有区别：

• 若类型实现 Copy 特征，该类型会被复制进 HashMap，因此无所谓所有权
• 若没实现 Copy 特征，所有权将被转移给 HashMap 中（使用引用要确保其生命周期足够长）

生命周期

变量的生命周期声明方式：

1
2

&'a i32     // 具有显式生命周期的引用
&'a mut i32 // 具有显式生命周期的可变引用

函数中的生命周期

需要标注生命周期的情况如下：

• 首先返回值必须是引用类型，可能会出现悬垂引用错误
• 存在多个参数时，如果编译器无法确定返回值需要跟随哪个参数的生命周期（哪怕这两个参数的生命周期是一样的），那么不标注就会报错
• 标注之后，编译时就会检查返回值使用会不会超出某个参数，如果发现超出就会报错（标注生命周期实际上不会更改任何返回值或者变量的真实生命周期，只是告诉编译器当返回值的生命周期不与较短的参数生命周期一致时，不予通过）

1
2
3
4
5
6
7
8
9
10

// 用'a显式表示生命周期，此处的'a表示两个参数中较短的生命周期，需要提前标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {

// 特殊情况：返回值永远只和一个参数有关/返回值与参数无关
fn longest<'a>(x: &'a str, y: &str) -> &'a str { // 只与一个有关就只标注一个
    x
}
fn longest(_x: &str, _y: &str) -> String { // 与新建变量有关尽量不返回引用
    String::from("really long string")
}

结构体中的生命周期

如果结构体的字段值类型为引用型，也需要标注生命周期'a（a可以任意替换）

作用是避免编译器报错、同时(提醒编译器)在编译时就检查其是否不超过原变量的生命周期

1
2
3

struct ImportantExcerpt<'a> {
    part: &'a str,
} // 只要在结构体每一个引用标注上生命周期即可，此处也需要提前声明<>

生命周期声明消除

为何在只有一个参数时可以不标注生命周期？

存在以下三个步骤可以省略生命周期声明（函数中参数的生命周期是输入生命周期，返回值为输出）：

1. 每一个引用参数都会获得独自的生命周期（所以不声明则多个参数有各自的生命周期声明）

   1	fn foo<'a, 'b>(x: &'a i32, y: &'b i32) // 所以不显式标出不知道跟随a还是b

2. 若只有一个输入生命周期（函数参数中只有一个引用类型），那么该生命周期会被赋给所有的输出生命周期，也就是所有返回值的生命周期都等于该输入生命周期

   1	fn foo<'a>(x: &'a i32) -> &'a i32 // 所以单个参数可以省略

3. 若存在多个输入生命周期，且其中一个是 &self 或 &mut self，则 &self 的生命周期被赋给所有的输出生命周期

方法中的生命周期

• 类似于泛型结构体
• 方法签名中一般不需要标注，因为有&self参数（根据以上第三条规则）

1
2
3
4
5
6
7
8
9

struct ImportantExcerpt<'a> {
    part: &'a str,
}

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

静态生命周期

拥有'static生命周期声明的引用生命周期是整个程序

1

let s: &'static str = "我没啥优点，就是活得久，嘿嘿";

属性

属性是一种元数据，用于修改编译器的行为、提供额外信息或影响代码生成方式

使用#[]语法

常见类型

#[derive()] 自动派生特征

用于让编译器自动为结构体或枚举实现特定的 trait（特征），如 Debug、Clone 等

注意只针对结构体与枚举，同时在实现某特征时（比如Copy）结构体中不能够有String这种无法自动实现Copy的字段

#[cfg(...)] 条件编译

用于根据特定 条件选择性地编译代码，例如目标平台：

1
2
3
4
5
6
7
8
9

#[cfg(target_os = "linux")]
fn platform_specific() {
    println!("Running on Linux!");
} // 只在linux上面编译

#[cfg(feature = "logging")]
fn log_message() {
    println!("Logging is enabled");
} // 启用了feature特征才能编译（feature特征是cargo.toml中定义的）

#[test] Rust 测试函数

用于标记测试函数，让 cargo test 自动运行它

错误处理

panic

• 标识不可恢复错误
• 有被动与主动触发两种情况

主动触发：使用panic!宏

1
2
3

fn main() {
    panic!("crash and burn");
} // 会打印出一个错误信息，展开报错点往前的函数调用堆栈，最后退出程序

Result

标识可恢复的错误

1
2
3
4

enum Result<T, E> {
    Ok(T),
    Err(E),
}

返回了该枚举类型之后就可以使用match来匹配解析

1
2
3
4
5
6
7
8
9
10

let f = match f {
       Ok(file) => file,
       Err(error) => match error.kind() {
           ErrorKind::NotFound => match File::create("hello.txt") {
               Ok(fc) => fc,
               Err(e) => panic!("Problem creating the file: {:?}", e),
           },
           other_error => panic!("Problem opening the file: {:?}", other_error),
       },
   }; // 一个打开文件的返回处理

如果不需要处理错误情况（即要么Ok()要么panic()，就使用unwrap()/expect）

1
2
3
4
5
6
7
8

let f = File::open("hello.txt").unwrap();
// 要么返回正确值要么直接panic

let f = File::open("hello.txt").expect("Failed to open hello.txt");
// 与unwrap()一样，只不过会报出里面的信息

// 改变错误类型：假设有f1(T)返回值T1类型，f2(F)返回值F2类型
let n: u8 = "1".parse().map(f1).map_err(f2) //原本返回T/F,现在返回T1/F1

传播错误

如果需要上级来处理这个函数中出现的错误呢？

返回Result<, >类型

• 使用match匹配，用分支来操作/返回
• 使用宏?

?功能类似于match

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// match写法
let f = File::open("hello.txt");
let mut f = match f {
    Ok(file) => file,
    Err(e) => return Err(e),
};
let mut s = String::new();
match f.read_to_string(&mut s) {
    Ok(_) => Ok(s),
    Err(e) => Err(e),
}

// ？写法：Err则该函数返回，Ok则语句返回正确值
let mut f = File::open("hello.txt")?;
let mut s = String::new();
f.read_to_string(&mut s)?;
Ok(s)
// ？同时可以进行类型提升，把所有的错误类型都提升为std::error::Error
// 此时就是返回Result<Ok值, Box<dyn std::error::Error>>

// ？可以链式调用
let mut s = String::new();
File::open("hello.txt")?.read_to_string(&mut s)?;
Ok(s)

注：

• ?操作符一定需要一个变量来承接正确的值
• 函数一定要是Result<, >返回值

Option与Result的转换

1
2
3

Option`转`Result`: 使用`.ok_or()`或`.ok_or_else()
// Option<T>	Result<T, E>
let res1: Result<T, E> = Option类型值.ok_or(E类型值);

1
2
3
4
5
6

Result`转`Option`: 丢弃错误使用`ok()`，丢弃成功值使用`.err()
// Option<T>	Result<T, E>
let opt1: Option<T> = Result类型值.ok();  

// Option<E>	Result<T, E>
let opt1: Option<E> = Result类型值.err(); // 如果Result类型值是ok()则丢弃

包与模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14

my_project/
├── Cargo.toml
└── src/
    ├── lib.rs         # library crate (名为 my_project)
    ├── main.rs        # binary crate (名为 my_project)
    └── bin/
        ├── tool1.rs   # binary crate (名为 tool1)
        └── tool2.rs   # binary crate (名为 tool2)
├── tests			   # 集成测试文件
│   └── some_integration_tests.rs
├── benches			   # 基准性能测试文件
│   └── simple_bench.rs
└── examples		   # 项目示例
    └── simple_example.rs

1

Package` => `Crate` => `mod

Package(包)

一个Package就是一个项目，包含一个或多个Crate（最多一个）

每个 Package 必须包含一个 Cargo.toml 文件来描述包的元信息和依赖

Crate(单元/箱)

• crate 是一个 Rust 项目或库的最小单元，即需要一起编译不可继续拆分
• 分为lib单元（入口文件一般为src/lib.rs；编译为库文件.rlib；不可单独执行，可以为其他项目提供依赖）和二进制单元（入口文件一般为src/main.rs或者在 src/bin/ 目录下；编译为可执行文件）
• 一个Package最多可以包含一个库单元和多个二进制单元，也可以只包含一个库单元/一个或几个二进制单元
• 对于二进制单元，src/main.rs是默认的crate，其他的crate都在src/bin/（或其他）目录下，且文件可以单独编译（一个文件就是一个crate）

考虑划分多个 crate 当：

1. 部分代码需要作为独立库被其他项目使用
2. 项目包含多个独立可执行工具
3. 某些功能需要单独编译和测试
4. 需要减少编译时间（修改一个 crate 不会导致其他 crate 重新编译）

Mod(模块)

使用模块只是为了更好地组织代码，同时控制它们的可见性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 定义语法
mod A {
	mod B {fn B1(){}} //可以嵌套
	mod C {fn C1(){}}
}

// 路径引用
fn D() {
    // 绝对路径
    crate::A::B::B1(); 
    //相对路径：只能以super/self/模块名或Crate开头
    A::B::B1(); // 在同一个Crate根部的相对路径可以直接这么写
}

// 可见性设置
pub mod hosting { // 模块写pub仅代表其可被访问，而其中的函数等还是对外界不可见
    pub fn add_to_waitlist() {} // 函数也需以pub开头
}

• 一个Crate是一棵模块树，而src/main.rs及src/lib.rs就是该树的根
• 模块A包含模块B，则A是B的父模块，B是A的子模块
• 模块中可以定义各种Rust类型，如函数、结构体、枚举、特征等
• 在同一个Crate根下的模块，相互引用的相对路径可以直接以对方模块名称开头；在同一父模块下的两个子模块，若在同文件中实现则也可以以对方模块名称开头，否则需要通过super::来使用父模块中转
• 将结构体设置为 pub，但它的所有字段依然是私有的；将枚举设置为 pub，它的所有字段也将对外可见
• 可以把模块实现放入对应等级的*.rs文件中，*要等同于模块名（文件中便不必再写），模块的定义/声明还是在父文件/模块中

use

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 基本引用方式：绝对或相对路径
use crate::front_of_house::hosting; // 引入模块
use front_of_house::hosting::add_to_waitlist; // 引入函数

// as别名
use std::fmt::Result;
use std::io::Result as IoResult;

// 引入再导出
pub use crate::front_of_house::hosting;

// 简化引入
use std::collections::{HashMap,BTreeMap,HashSet};
use std::{cmp::Ordering, io};

use std::io;
use std::io::Write;
use std::io::{self, Write};

use std::collections::*; // 引入模块下所有项

注：

• 如果引入的函数存在同名的情况时，需使用模块名::函数名的方式或者as别名的方式来区分

限制可见性

• pub 意味着可见性无任何限制
• pub(crate) 表示在当前包可见
• pub(self) 在当前模块可见
• pub(super) 在父模块可见
• pub(in <path>) 表示在某个路径代表的模块中可见，其中 path 必须是父模块或者祖先模块

函数式编程

简单来说，迭代器/高阶函数是“流水线模板”，提供规范流程（比如map\filter等等）；闭包是“可替换的工具”，即灵活调整传入的参数；而这两者都需要满足“不可变性”的安全要求

闭包

闭包是一种匿名函数，它可以赋值给变量也可以作为参数传递给其它函数，不同于函数的是，它允许捕获调用者作用域中的值

闭包语法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 定义闭包
|param1, param2,...| {
    语句1;
    语句2;
    返回表达式
} 
|param1| 返回表达式 // 只需要有一个表达式时
|| {} // 如果不需要参数时

// 结构体中的闭包
struct Cacher<T>
where T: Fn(u32) -> u32,
{
    query: T,
}  // 等价于struct Cacher<T: Fn(u32) -> u32>，query字段同样也可以使用一个符合的函数作为值

注：

• 闭包函数中是否标注类型皆可（如果未使用过则需要标注），同样可以以此省略返回值
• 闭包函数中的类型不可以是泛型，所以每次使用参数要求同类型

三种Fn特征

FnOnce: 强制需要闭包所捕获变量的所有权

FnMut: 用于闭包函数内需要改变被捕获变量的值的情况，需要闭包和捕获变量都有mut声明

Fn: 以不可变借用的方式捕获环境中的值(与FnMut不兼容，即不可改变捕获函数的值)

注：

• 在FnOnce作为传入闭包的特征约束时，传入闭包和其捕获函数的所有权都会在第一次调用时被消耗；特殊情况：同时要求FnOnce与Copy（闭包会实现Copy，而其捕获的变量也会尽量实现Copy）

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  fn main() { let x = vec![1, 2, 3]; fn_once(|z|{z == x.len()}) } fn fn_once<F>(func: F) where F: FnOnce(usize) -> bool, { println!("{}", func(3)); // 捕获的Vec的所有权，闭包与变量一起消耗 println!("{}", func(4)); } fn fn_once<F>(func: F) where F: FnOnce(usize) -> bool + Copy,// 改动在这里 { println!("{}", func(3)); // 闭包实现Copy，不消耗；尽可能捕获可Copy的值如x.len()，没有则会在编译报错 println!("{}", func(4)); }

• 由上所知，闭包的捕获行为会根据上下文约束来调整

• 闭包自动实现Copy特征的规则是，只要闭包捕获的类型都实现了Copy特征的话，这个闭包就会默认实现Copy特征

• FnOnce会消耗闭包的所有权；但无论按值还是按引用传递，Fn/FnMut通常都不会消耗闭包的所有权。即在传入一个有Fn(Mut)特征约束的函数之后，一个闭包函数的变量还可以继续使用

• 所有的闭包都自动实现了 FnOnce 特征，因此任何一个闭包都至少可以被调用一次；没有移出所捕获变量的所有权的闭包自动实现了 FnMut 特征；不需要对捕获变量进行改变的闭包自动实现了 Fn 特征

move

1

let update_string =  move || println!("{}",s); // move强制闭包获取变量所有权

闭包作为函数返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn factory() -> Fn(i32) -> i32 {
    let num = 5;
    |x| x + num
} // 报错，特征不是类型，需要其他辅助声明

fn factory(x:i32) -> impl Fn(i32) -> i32 {
    let num = 5;
    if x > 1{
        move |x| x + num
    } else {
        move |x| x - num
    }
} // 报错，返回的内容要求是同一类型，此处虽然满足同一特征，但属于不同类型

fn factory(x:i32) -> Box<dyn Fn(i32) -> i32> {
    let num = 5;
    if x > 1{
        Box::new(move |x| x + num)
    } else {
        Box::new(move |x| x - num)
    }
} // 正确，使用智能指针将其视为同一类型

迭代器Iterator

迭代器允许我们迭代一个连续的集合，例如数组、动态数组 Vec、HashMap 等，在此过程中，只需关心集合中的元素如何处理，而无需关心如何开始、如何结束、按照什么样的索引去访问

1、.next是迭代器中取下一个值的方式,返回Option<T>

1
2
3
4
5

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    // 省略其余有默认实现的方法
} // 迭代器实现的特征Interator

2、将数组转化为迭代器的三种方式(Vec动态数组实现的IntoIterator中的函数)：

• into_iter 会夺走所有权
• iter 是借用
• iter_mut 是可变借用（next方法返回的&mut）

3、迭代器的消费者与适配器（都是迭代器特征中的方法）

• 消费者：消费掉迭代器，返回一个值

  会拿走迭代器的所有权，即调用它之后迭代器无法再使用

• 适配器：返回一个新的迭代器，是链式调用的基础

  因此在链式调用末尾需要一个消费者来收尾用以返回一个值

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  //例1 let v1: Vec<i32> = vec![1, 2, 3]; let v2: Vec<_> = v1.iter().map(|x| x + 1).collect(); // collect():消费掉迭代器，把值收集成特定类型（需要显式注明） // .map():对迭代器的每一个值操作，换为另一个新值 assert_eq!(v2, vec![2, 3, 4]); //例2 let names = ["sunface", "sunfei"]; let ages = [18, 18]; let folks: HashMap<_, _> = names.into_iter().zip(ages.into_iter()).collect(); // .zip():将两个迭代器压缩在一起，形成Iterator<Item=(ValueFromA, ValueFromB)> 这样的新的迭代器 //例3：闭包用作适配器参数 fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> { shoes.into_iter().filter(|s| s.size == shoe_size).collect() } // filter():对迭代器每个值进行过滤，若满足则保留 // 此处闭包同样可以捕捉环境变量

深入类型

类型转换

as转换

1
2
3

let a = 3.1 as i8;
let b = 100_i8 as i32;
let c = 'a' as u8; // 将字符'a'转换为整数，97

注：

转换不具有传递性：就算 e as U1 as U2 是合法的，也不能说明 e as U2 是合法的（e 不能直接转换成 U2）

TryInto转换

1
2
3

let a: u8 = 10;
let b: u16 = 1500;
let b_: u8 = b.try_into().unwrap(); //尝试进行一次转换，并返回一个 Result

注：try_into 转换会捕获大类型向小类型转换时导致的溢出错误

From和Into特征

• From<T>：定义如何从类型 T 转换到当前类型。
• Into<T>：自动为实现了 From 的类型生成反向转换。

1
2
3
4
5
6
7
8
9
10

impl From<i32> for MyType {
    fn from(value: i32) -> Self {
        MyType(value)
  
    
    }
}

let a = MyType::from(42);  // 显式调用
let b: MyType = 42.into(); // 自动推导（需类型注解）

newtype

使用元组结构体的方式将已有的类型包裹起来：struct Meters(u32);，那么此处 Meters 就是一个 newtype

• 自定义类型可以让我们给出更有意义和可读性的类型名，例如与其使用 u32 作为距离的单位类型，我们可以使用 Meters，它的可读性要好得多
• 对于某些场景，只有 newtype 可以很好地解决
• 隐藏内部类型的细节

为外部类型实现外部特征

孤儿规则：要为类型 A 实现特征 T，那么 A 或者 T 必须至少有一个在当前的作用范围内

1
2
3
4
5
6
7
8
9
10

// 例：想为Vec实现Display特征，但这两个都在标准库中
use std::fmt;
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{}]", self.0.join(", "))
    }
}

// 注：包裹一样类型的newtype是不同的类型,newtype与其内部包裹的类型同理

类型别名

1

type Meters = u32

注：类型别名仅仅为了更好的可读性，与原类型没有任何区别

1
2
3
4
5
6
7
8

// 应用：减少代码模板的使用
let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));

type Thunk = Box<dyn Fn() + Send + 'static>;
let f: Thunk = Box::new(|| println!("hi"));

//常用于简化Result<T, E> 枚举中
type Result<T> = std::result::Result<T, std::io::Error>; // 此处为std::io库中Error类型的简化

不定长类型DST

定长类型：基础类型、集合 Vec、String 和 HashMap 等(其在栈上拥有固定大小的指针)

不定长类型：str、特征对象

1
2
3

fn foobar_1(thing: &dyn MyThing) {}     // OK
fn foobar_2(thing: Box<dyn MyThing>) {} // OK
fn foobar_3(thing: MyThing) {}          // ERROR!

注：只能间接使用DST，通过引用或Box来使用

Sized特征

怎么保证泛型参数是固定大小的类型？

1
2

fn generic<T(: Sized)>(t: T) { // 自动补全了Sized特征
}

枚举与整数

枚举到整数很容易，但反过来需要借助三方库来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

enum MyEnum {
    A = 1,
    B,
    C,
}
fn main() {
    // 将枚举转换成整数，顺利通过
    let x = MyEnum::C as i32;
    // 将整数转换为枚举，失败
    match x {
        MyEnum::A => {}
        MyEnum::B => {}
        MyEnum::C => {}
        _ => {}
    }
}

// 使用num-traits/num-derive库
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;

match FromPrimitive::from_i32(x) {
    Some(MyEnum::A) => println!("Got A"),
    Some(MyEnum::B) => println!("Got B"),
    Some(MyEnum::C) => println!("Got C"),
    None            => println!("Couldn't convert {}", x),
}

智能指针

智能指针与普通自定义结构体区别：实现了Deref和Drop特征

智能指针用于一些较引用更复杂的场景

Box<T>堆对象分配

Box 简单的封装，用于将值存储在堆上

使用场景：

• 特意的将数据分配在堆上
• 数据较大时，又不想在转移所有权时进行数据拷贝
• 类型的大小在编译期无法确定，但是我们又需要固定大小的类型时
• 特征对象，用于说明对象实现了一个特征，而不是某个特定的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 将数据存储在堆上
let a = 3; // a在栈上
let a = Box::new(3); // 在堆上

// 避免栈上数据拷贝
let arr = [0;1000];
let arr1 = arr; // 此时两份数据，是深拷贝

let arr = Box::new([0;1000]);
let arr1 = arr; // 所有权顺利转移给 arr1，arr 不再拥有所有权

// 提供固定大小
enum List {
    Cons(i32, List), // 递归类型：无法确定大小，因为DST报错
    Nil,
}
enum List {
    Cons(i32, Box<List>),
    Nil,
}

// 特征对象
// 想实现不同类型组成的数组只有两个办法：枚举和特征对象
// 特征对象其实就是把DST类型的特征转为固定大小

另：Box::leak可以真正将一个运行期的值转化为'static，如果只标注'static可能无法成功

Deref解引用

1

Deref` 可以让智能指针像引用那样工作，这样你就可以写出同时支持智能指针和引用的代码，例如 `*T

\*: 对常规引用使用*操作符，即可以通过解引用的方式获取到内存地址对应的数据值

智能指针解引用： 在使用给定的智能指针时，直接使用*解引用即可

在智能指针解引用时，实际上调用了*(y.deref())方法：y.deref()先返回了值的常规引用

1
2
3
4
5
6
7
8

// 如果要实现自己的智能指针同样要实现Deref特征
use std::ops::Deref;
impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
} // 实现该特征后才能使用*解引用

函数/方法中的隐式Deref转换

函数和方法的传参中有Deref的隐式转换。

若一个类型实现了 Deref 特征，那它的引用在传给函数或方法时，会根据参数签名来决定是否进行隐式的 Deref 转换(Deref支持连续的隐式转换)

总结

• 一个类型为 T 的对象 foo，如果 T: Deref<Target=U>，那么，相关 foo 的引用 &foo 在应用的时候会自动转换为 &U
• 在解引用时自动把智能指针和 &&&&v 做引用归一化操作，转换成 &v 形式，最终再对 &v 进行解引用（即将智能指针脱壳为内部的引用类型即&v， 把多级引用归一为一级&v）

Drop释放资源

指定在一个变量超出作用域时，执行一段特定的代码，最终编译器将帮你自动插入这段收尾代码（无需在每一个使用该变量的地方，都写一段代码来进行收尾工作和资源释放）

1
2
3
4
5

impl Drop for Foo {
    fn drop(&mut self) { // 传入的是可变借用
        println!("Dropping Foo!")
    }
}

Drop 的顺序

• 变量级别，按照逆序的方式（_x 在 _foo 之前创建，因此 _x 在 _foo 之后被 drop）
• 结构体内部，按照顺序的方式

注：

• Rust 自动为几乎所有类型都实现了 Drop 特征（除了栈上的简单类型）
• 不允许显式地调用析构函数变量名.drop()，但可以调用函数drop(变量名)（drop()函数会拿走目标值的所有权）
• Copy和Drop互斥，不会在一种类型上面出现（为了防止重复释放内存）

Rc

通过引用计数的方式，允许一个数据资源在同一时刻拥有多个所有者

实现机制就是 Rc 和 Arc，前者适用于单线程，后者适用于多线程

Rc<T>

引用计数：通过记录一个数据被引用的次数来确定该数据是否正在被使用。当引用次数归零时，就代表该数据不再被使用，因此可以被清理释放

当我们希望在堆上分配一个对象供程序的多个部分使用且无法确定哪个部分最后一个结束时，就可以使用 Rc 成为数据值的所有者

1
2

let a = Rc::new(String::from("hello, world")); // 创建时引用计数+1，此时Rc::strong_count(&a) 返回的值是 1
let b = Rc::clone(&a); // clone 仅仅复制了智能指针并增加了引用计数，并没有克隆底层数据；同样可以使用a.clone()

注：

• 这几个智能指针都是相同的所以Rc::strong_count(&a/b/c)皆可
• 当其中一个变量离开作用域被销毁后，计数-1，但只有当计数为0时，这个指针和指向的底层数据才会销毁
• Rc<T>指向的是底层数据的不可变应用(相当于有多个不可变引用)
• 实现了Deref特征，可以直接使用里面的数值

Arc

• 原子化的 Rc<T> 智能指针,保证我们的数据能够安全的在线程间共享
• 与Rc的API完全相同
• Arc 和 Rc 并没有定义在同一个模块，前者通过 use std::sync::Arc 来引入，后者通过 use std::rc::Rc

Cell和RefCell

解决问题（相较于引用）：

• 可以通过不可变引用来修改数据
• 绕过编译期借用检查
• 实现了部分可变性（比如标定结构体某个字段为内部可变）

Cell

Cell 和 RefCell 在功能上没有区别，区别在于 Cell<T> 适用于 T 实现 Copy 的情况

1
2
3
4
5

let c = Cell::new(42);
let val = c.get(); // 复制值（42）
c.set(100); // 替换新值，仍然拥有所有权不会报错

let c = Cell::new(String::from("asdf")); // 这样会报错

RefCell

• 允许通过不可变引用 (&T) 修改内部数据（内部可变性）。
• 在运行时（而非编译期）检查借用规则，违反规则时触发 panic。

1

let s = RefCell::new(String::from("hello, world")); // s为RefCell<T>类型

1
2
3
4
5
6
7
8
9
10

struct Logger {
    logs: RefCell<Vec<String>>, // 内部可变
}

impl Logger {
    fn log(&self, message: &str) {
        // 通过不可变的 &self 修改 logs！
        self.logs.borrow_mut().push(message.to_string());
    }
}

注：RefCell 的核心机制是，将一个本应可变的数据（如 String）包裹在“壳子”（RefCell）里，然后通过这个壳子的不可变引用（&RefCell<T>），在运行时安全地修改内部数据

循环引用与自引用

面临问题：当使用RefCell<Rc<List>>时，可以a指向b，b再指向a，出现循环引用，最后Rc计数无法归0

Weak

仅保存一份指向数据的弱引用，不保证引用关系依然存在，无法阻止所引用的内存值被释放

Weak 通过 use std::rc::Weak 来引入，它具有以下特点:

• 可访问，但没有所有权，不增加引用计数，因此不会影响被引用值的释放回收
• 可由 Rc<T> 调用 Rc::downgrade 方法转换成 Weak<T>
• Weak<T> 可使用 upgrade 方法转换成 Option<Rc<T>>，如果资源已经被释放，则 Option 的值是 None
• 常用于解决循环引用的问题

多线程并发编程

并发：同时存在多个动作

并行：可以同时执行多个动作

关系：并发程序可以由人编写，但只有有多个CPU内核时才可以并行执行；

并行一定并发，但只有多核时并发才能够并行

使用线程

风险

由于多线程的代码是同时运行的，因此我们无法保证线程间的执行顺序，这会导致一些问题：

• 竞态条件(race conditions)，多个线程以非一致性的顺序同时访问数据资源
• 死锁(deadlocks)，两个线程都想使用某个资源，但是又都在等待对方释放资源后才能使用，结果最终都无法继续执行
• 一些因为多线程导致的很隐晦的 BUG，难以复现和解决

创建线程：thread::spawn

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

use std::thread;
use std::time::Duration;

fn main() {
    let handle = 
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1)); // thread::sleep 会让当前线程休眠指定的时间，随后其它线程会被调度运行
        }
    }); // 线程内部的代码使用闭包来执行
    
    handle.join().unwrap(); // 让当前线程阻塞，直到它等待的子线程的结束
    
    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
} // main 线程一旦结束，程序就立刻结束，因此需要保持它的存活，直到其它子线程完成自己的任务

注：

• 线程的启动结束时间点都是不固定的
• 由上一条，为了保证子线程中的变量一直有效，在子线程的闭包中捕获了环境变量时，需要使用move来转移所有权
• 主线程（main）退出时，会强制终止所有子线程（无论它们是否在运行）；父线程（非主线程）退出时，不会影响它创建的子线程
• thread::spawn 的返回值是std::thread::JoinHandle类型，表示对线程的控制权，允许主线程通过 join() 等待子线程结束，同样可以使用数组收集

多线程的性能

当任务是 CPU 密集型时，就算线程数超过了 CPU 核心数，也并不能帮你获得更好的性能

当你的任务大部分时间都处于阻塞状态时，就可以考虑增多线程数量（典型就是网络 IO 操作）

线程屏障Barrier

让多个线程都执行到某个点后，才继续一起往后执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

use std::sync::{Arc, Barrier};
use std::thread;

fn main() {
    let barrier = Arc::new(Barrier::new(3));
    let mut handles = vec![];

    for i in 0..3 {
        let barrier = barrier.clone();
        handles.push(thread::spawn(move || {
            println!("线程 {}: 阶段1", i);
            barrier.wait(); // 等待所有线程完成阶段1
            println!("线程 {}: 阶段2", i);
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }
}

注：

• 需要Arc智能指针，作用是允许多个线程同时拥有同一数据（跨线程Rc）
• Barrier::new(n)中的n值一定要与实际调用wait()的线程数相等

多线程局部变量

标准库thread_local

1
2
3
4
5
6
7
8
9
10
11
12

// 定义
thread_local! {
    static MY_TLS: 类型 = 初始化值; // 必须使用static声明为全局变量，一般使用RefCell/Cell/Mutex包裹
}

// 语法：变量名.with(|绑定名| { 操作 }); 闭包传入参数即为局部变量
thread::spawn(|| {
    // 每个线程独立操作 COUNTER
    COUNTER.with(|c| {
          *c.borrow_mut() += 1;
          println!("Thread {:?}: {}", thread::current().id(), c.borrow());
});

注：如果想使用多个局部变量的闭包函数，使用嵌套

同样还有使用use thread_local::ThreadLocal;引用的三方库，这个库不仅仅使用了值的拷贝，而且还能自动把多个拷贝汇总到一个迭代器中，最后进行求和

条件控制线程的挂起和执行：let pair = Arc::new((Mutex::new(false), Condvar::new()));

只会调用一次的函数：static INIT: Once =Once::new();

1

INIT.call_once(|| {unsafe {VAL = 2;}});

线程同步

消息传递

线程通过发送和接收消息来通信，而非直接共享内存

标准库工具mpsc，允许多发送者，单接收者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use std::sync::mpsc;

// 创建一个消息通道, 返回一个元组：(发送者，接收者)
let (tx, rx) = mpsc::channel();

// 创建线程，并发送消息
thread::spawn(move || {
    tx.send(1).unwrap(); // 发送一个数字1, send方法返回Result<T,E>，通过unwrap进行快速错误处理

    // 下面代码将报错，因为编译器自动推导出通道传递的值是i32类型，那么Option<i32>类型将产生不匹配错误
    // tx.send(Some(1)).unwrap()
});

// 在主线程中接收子线程发送的消息并输出
println!("receive {}", rx.recv().unwrap());

// 尝试接收一次消息，不会阻塞线程，当通道中没有消息时，它会立刻返回一个错误
println!("receive {:?}", rx.try_recv());


// 连续接收消息
thread::spawn(move || {
    let vals = vec![
        String::from("hi"),
        String::from("from"),
        String::from("the"),
        String::from("thread"),
    ];
    for val in vals {
        tx.send(val).unwrap();
        thread::sleep(Duration::from_secs(1));
    }
});

for received in rx {
    println!("Got: {}", received);
}

// 使用多发送者：克隆发送者，其余的线程拿走拷贝
let tx1 = tx.clone();
thread::spawn(move || {
    tx1.send(String::from("hi from cloned tx")).unwrap();
}); 
for received in rx {
    println!("Got: {}", received);
}// 需要所有的发送者都被drop掉后，接收者rx才会收到错误，进而跳出for循环，最终结束主线程；
// 两个子线程谁先创建完成是未知的，哪条消息先发送也是未知的

// 同步通道设置
let (tx, rx)= mpsc::sync_channel(n); // n用来指定同步通道的消息缓存条数

• tx,rx对应发送者和接收者，它们的类型由编译器自动推导: tx.send(1)发送了整数，因此它们分别是mpsc::Sender<i32>和mpsc::Receiver<i32>类型，(一旦类型被推导确定，该通道就只能传递对应类型的值)
• 接收消息的操作rx.recv()会阻塞当前线程，直到读取到值，或者通道被关闭
• 需要使用move将tx的所有权转移到子线程的闭包中
• 使用通道来传输数据，一样要遵循 Rust 的所有权规则：
  • 若值的类型实现了Copy特征，则直接复制一份该值，然后传输过去，例如之前的i32类型
  • 若值没有实现Copy（如String类型），则它的所有权会被转移给接收端，在发送端继续使用该值将报错
• 异步中只有接收者会被阻塞，同步中发送者也会因为接收者接收不到消息被阻塞
• 所有发送者被drop或者所有接收者被drop后，通道会自动关闭

锁、Condvar

使用共享内存来实现同步性

面临问题：多个线程同时修改同一数据时，结果不可预测；线程执行顺序影响最终结果

互斥锁Mutex

同一时间，只允许一个线程A访问该值，其它线程需要等待A访问完成后才能继续

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 创建实例：锁的容器
let m = Mutex::new(5);
{
    // lock返回的是Result
    let mut num = m.lock().unwrap(); // .lock()向m申请锁的所有权（简称“锁”）：在获取锁之前会阻塞线程。同时只能有一个线程获得锁
    // 当拥有锁的线程panic，其他线程永远得不到这个锁
    *num = 6;
    // 锁自动被drop
}

// 多线程中使用锁
use std::sync::{Arc, Mutex};
use std::thread;

let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    // 创建子线程，并将`Mutex`的所有权拷贝传入到子线程中，子线程需要通过move拿走锁的所有权
    let handle = thread::spawn(move || {
        let mut num = counter.lock().unwrap();
		*num += 1;
    });
    handles.push(handle);
}
// 等待所有子线程完成
for handle in handles {
    handle.join().unwrap();
}

• m.lock()返回一个智能指针MutexGuard<T>，拥有Deref特征（自动解引用获取引用类型）与Drop特征（超出作用域自动释放锁）
• Rc<T>/RefCell<T>用于单线程内部可变性， Arc<T>/Mutex<T>用于多线程内部可变性

死锁

• 在另一个锁还未被释放时去申请新的锁，就会触发
• 当我们拥有两个锁的容器，且两个线程各自使用了其中一个锁，然后试图去访问另一个锁时，就可能发生死锁
• try_lock(): 尝试去获取一次锁，如果无法获取会返回一个错误，因此不会发生阻塞

1
2

let guard = MUTEX2.lock().unwrap();
let guard = MUTEX2.try_lock(); // 返回错误

读写锁RwLock

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Mutex`会对每次读写都进行加锁，但某些时候，我们需要大量的并发读，`Mutex`就无法满足需求了，此时就可以使用`RwLock
use std::sync::RwLock;

fn main() {
    let lock = RwLock::new(5);

    // 同一时间允许多个读
    {
        let r1 = lock.read().unwrap();
        let r2 = lock.read().unwrap();
        assert_eq!(*r1, 5);
        assert_eq!(*r2, 5);
    } // 读锁在此处被drop

    // 同一时间只允许一个写
    {
        let mut w = lock.write().unwrap();
        *w += 1;
        assert_eq!(*w, 6);

        // 以下代码会阻塞发生死锁，因为读和写不允许同时存在
        // 写锁w直到该语句块结束才被释放，因此下面的读锁依然处于`w`的作用域中
        // let r1 = lock.read();
        // println!("{:?}",r1);
    }// 写锁在此处被drop
}

我们也可以使用try_write和try_read来尝试进行一次写/读，若失败则返回错误

1

Err("WouldBlock")

条件变量Condvar控制线程同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

use std::sync::{Arc, Mutex, Condvar};

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let (lock, cvar) = &*pair;

// 消费者线程（等待条件成立）
let consumer = thread::spawn(move || {
    let mut condition = lock.lock().unwrap();
    while !*condition {
        condition = cvar.wait(condition).unwrap(); // 释放锁并等待
    }
    println!("Condition is now true!");
});

// 生产者线程（修改条件并通知）
thread::spawn(move || {
    let mut condition = lock.lock().unwrap();
    *condition = true;          // 修改条件
    cvar.notify_one();          // 唤醒消费者
});

consumer.join().unwrap();

消费者线程需等待条件成立才可执行：获取互斥锁检查条件是否成立 => 不成立则进入循环 => cvar.wait(condition).unwrap()执行时立即释放互斥锁（交由其他线程修改） => 其他线程修改后使用cvar.notify_one()唤醒该线程 => 返回条件重新检查

注：

• notify_one()
  1
  2
  
  随机唤醒一个正在
  
  wait()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  
    的线程（由操作系统调度决定）。
  
    - 如果有多个线程在等待，不保证顺序（可能是最早等待的，也可能是随机的）。
    - 如果没有线程在等待，这次通知会被丢弃（无效果）。
  
  - `notify_all()`： 唤醒所有正在 `wait()` 的线程，它们会竞争锁并依次检查条件。
  
  ##### `Atomic`原子类型与内存顺序
  
  为解决锁的性能问题而生，通过 CPU 的原子指令实现无锁线程安全操作
  
  | 特性             | 说明                                                         |
  | ---------------- | ------------------------------------------------------------ |
  | **不可分割性**   | 操作一旦开始，不会被其他线程或 CPU 中断。                    |
  | **线程安全**     | 多线程同时执行同一原子指令时，结果依然正确                   |
  | **硬件直接支持** | 由 CPU 通过特定指令（如 `LOCK` 前缀）实现，而非软件模拟。    |
  | **内存顺序控制** | 通过 `Ordering` 参数指定操作前后的指令重排规则（如 `SeqCst`）。 |
  
  use std::sync::atomic::AtomicUsize;