25. 三万字 | 2021 年 Rust 行业调研报告_rust 调查

文前

Rust 语言是一门通用系统级编程语言，无GC且能保证内存安全、并发安全和高性能而著称。自2008年开始由 Graydon Hoare 私人研发，2009年得到 Mozilla 赞助，2010年首次发布 0.1.0 版本，用于Servo 引擎的研发，于 2015年5月15号发布 1.0 版本。

自发布以来，截止到 2021 年的今天，经历六年的发展，Rust 得到稳步上升，已逐渐趋于成熟稳定。

至 2016 年开始，截止到 2021年，Rust 连续五年成为 StackOverflow 语言榜上最受欢迎的语言[1]。

 

2021年 2 月 9 号，Rust 基金会宣布成立。华为、AWS、Google、微软、Mozilla、Facebook 等科技行业领军巨头加入 Rust 基金会，成为白金成员，以致力于在全球范围内推广和发展 Rust 语言。

那 Rust 语言到底有何魅力，能让广大开发者和巨头公司这么感兴趣呢？

本文从 Rust 语言自身特性 和 Rust 行业应用盘点两个方面的社区调研来尝试来解答这个问题，希望通过这些简单但关键的数据来对 Rust 在当前各大领域应用有个比较全面且直观的印象，供想选择 Rust 的公司参考。

注明：本文中所罗列数据均来源于互联网公开内容。

认识 Rust 语言

编程语言设计在两个看似不可调和的愿望之间长期存在着矛盾对立。

• 安全 ( safe )。我们想要强类型系统来静态地消除大量错误。我们要自动内存管理。我们想要数据封装， 这样我们就可以对私有变量执行不变的对象的表示形式，并确保它们将不会被不受信任的代码破坏。

• 控制 (control )。至少对于 Web浏览器，操作系统，或游戏引擎这样的 系统编程 (system programming) 程序，约束它们性能或资源是一个重要的问题，我们想了解数据的字节级表示。我们想要用底层语言 (low-level programming) 的编程技术优化我们程序的时间和空间的使用。我们希望在需要时使用 裸机 。

然而，按照传统的看法，鱼和熊掌不能兼得。Java 之类的语言是我们极大的安全保证，但代价是牺牲对底层的控制。结果，对于许多系统编程应用程序，唯一现实的选择是使用一种像 C 或 C++ 提供细粒度的语言控制资源管理。但是，获得这种控制需要很高的成本。例如，微软最近报告说，他们修复的 70％ 安全漏洞都归因于内存安全违规行为 33[2]，并且都是能被强类型系统排除的问题。同样，Mozilla 报告指出，绝大多数关键 他们在Firefox中发现的错误是内存有关的16 [3]。

如果可以以某种方式两全其美: 安全系统编程的同时对底层有控制权，岂不美哉。因此，Rust 语言应运而生。

 

官方网如此介绍 Rust : 一门赋予每个人 构建可靠且高效软件能力的语言。

Rust 语言有三大优势值得大家关注：

1. 高性能。Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。

2. 可靠性。Rust 丰富的类型系统和所有权模型保证了内存安全和线程安全，让您在编译期就能够消除各种各样的错误。

3. 生产力。Rust 拥有出色的文档、友好的编译器和清晰的错误提示信息， 还集成了一流的工具——包管理器和构建工具， 智能地自动补全和类型检验的多编辑器支持， 以及自动格式化代码等等。

Rust 足够底层，如果有必要，它可以像 C 一样进行优化，以实现最高性能。

抽象层次越高，内存管理越方便，可用库越丰富，Rust 程序代码就越多，做的事情越多，但如果不进行控制，可能导致程序膨胀。

然而，Rust 程序的优化也很不错，有时候比 C 语言更好，C 语言适合在逐个字节逐个指针的级别上编写最小的代码，而 Rust 具有强大的功能，能够有效地将多个函数甚至整个库组合在一起。

但是，最大的潜力是可以无畏（fearless）地并行化大多数 Rust 代码，即使等价的 C 代码并行化的风险非常高。在这方面，Rust 语言是比 C 语言更为成熟的语言。

Rust 语言也支持高并发零成本的异步编程，Rust 语言应该是首个支持异步编程的系统级语言。

媲美 C / Cpp 的高性能

Rust vs C

 

Rust vs Cpp

 

Rust vs Go

 

用 Rust 编写的程序的运行时速度和内存使用量应该和用 C 编写的程序差不多，但这两种语言的总体编程风格不同，很难去概括它们的性能。

总的来说：

1. 抽象是一把双刃剑。Rust 语言抽象程度比 C 语言更高，抽象会隐藏一些不是那么优化的代码，这意味着，默认实现的 Rust 代码性能不是最好的。所以，你的 Rust 代码必须经过优化才能达到媲美 C 的性能。Unsafe Rust 就是高性能出口。

2. Rust 默认线程安全，消除数据竞争，让多线程并发编程更具实用价值。

3. Rust 在有些方面确实比 C 快。理论上，C 语言什么都可以做。但在实践中，C 抽象能力比较低，不那么现代化，开发效率比较低。只要开发者有无限时间和精力，就可以让 C 语言在这些方面比 Rust 更快。

因为 C 语言足以代表高性能，下面就分别谈一下 C 和 Rust 的异同。如果你熟悉 C/Cpp，也可以根据此对比来评估 Cpp 和 Rust。

Rust 和 C 都是硬件直接抽象

Rust 和 C 都是直接对硬件的抽象，都可看作一种「可移植汇编程序」。

Rust 和 C 都能控制数据结构的内存布局、整数大小、栈与堆内存分配、指针间接寻址等，并且一般都能翻译成可理解的机器代码，编译器很少插入 "魔法"。

即便 Rust 比 C 有更高层次的结构，如迭代器、特质（trait）和智能指针，它们也被设计为可预测地优化为简单的机器代码（又称 "零成本抽象"）。

Rust的类型的内存布局很简单，例如，可增长的字符串String 和 Vec 正好是{byte*, capacity, length}。Rust没有任何像 Cpp里的 移动 或 复制构造函数 这样的概念，所以对象的传递保证不会比传递指针或 memcpy 更复杂。

Rust 借用检查只是编译器对代码中引用的静态分析。生命周期（lifetime）信息早就在 中级中间语言（MIR） 生成前完全抽离了。

Rust 中不使用传统的异常处理，而是使用基于返回值的错误处理。但你也可以使用 恐慌（Panic）来处理像 Cpp 中那样的异常行为。它可以在编译时被禁用（panic = abort），但即便如此，Rust 也不喜欢 与 Cpp异常 或 longjmp 混在一起。

同样的 LLVM 后端

Rust与LLVM有很好的整合，所以它支持链接时间优化，包括ThinLTO，甚至是跨越C/C++/Rust语言边界的内联。也有按配置优化（Profile-guided Optimization，PGO）的支持。尽管 rustc 比 clang 生成的LLVM IR更加冗长，但优化器仍然能够很好地处理它。

C 语言用 GCC 编译比用 LLVM 更快，现在 Rust 社区也有人在开发 GCC 的 Rust 前端。

理论上，因为 Rust 有比C 更严格的不可变和别名规则，应该比 C 语言有更好的性能优化，但实际上并没有起到这样的效果。目前在LLVM中，超越 C语言的优化是一项正在进行的工作，所以Rust仍然没有达到其全部潜力。

都允许手工优化，但有一些小例外

Rust 的代码足够底层和可预测，可以通过手工调整它的优化到什么样的汇编代码。

Rust 支持 SIMD ，对内联和调用约定有很好的控制。

Rust 和 C 语言足够相似，C 语言的一些分析工具通常可以用于 Rust 。

总的来说，如果性能绝对关键，并且需要手工优化压榨最后一点性能，那么优化 Rus t 与 优化 C 语言并没有什么不同。

但是在一些比较底层的特性，Rust 没有特别好的替代方法。

• goto。Rust 中没有提供goto，不过你可以使用循环的 break 标签来代替。C 语言中一般使用 goto 来清理内存，但是 Rust 因为有确定性析构功能，所以不需要 goto。然而有一个 非标准的 goto 扩展，对性能优化比较有用。

• 栈内存分配alloca和C99可变长度数组，可以节省内存空间，减少内存分配次数。但这些即使在 C 语言中也是有争议的，所以Rust远离了它们。

Rust 相比 C 语言的一些开销

如果没有经过手工优化，Rust 因为其抽象表达也会有一些开销。

• Rust缺乏隐式类型转换和只用usize的索引，这导致开发者只能使用这种类型，哪怕只需要更小的数据类型。64位平台上用usize做索引更容易优化，而不需要担心未定义行为，但多余的bit位可能会给寄存器和内存带来更大的压力。而在 C 中，你可以选择 32位类型。

• Rust 中的字符串，总是会携带指针和长度。但是很多 C 代码中的函数只接收指针而不管大小。

• 像 for i in 0...len {arr[i]} 这样的迭代，性能取决于 LLVM 优化器能否证明长度匹配。有时候，它不能，并且边界检查也会抑制自动矢量化。

• C 语言比较自由，对于内存有很多“聪明”的使用技巧，但在 Rust 里就没这么自由了。但Rust仍然给了内存分配很多控制权，并且可以做一些基本的事情，比如内存池、将多个分配合并为一个、预分配空间等等。

• 在不熟悉 Rust 借用检查的情况下，可能会用 Clone 来逃避使用引用。

• Rust 的标准库中 I/O 是不带缓存的，所以需要使用 BufWriter 来包装。这就是为什么有些人说 Rust 写的代码还不如 Python 快的原因，因为 99% 的时间都用在 I/O上了。

可执行文件大小

每个操作系统都有一些内置的标准C库，其中有大约30MB的代码。C 语言的执行文件，可以“免费”使用这些库。

一个小的 "Hello World " 级 C 可执行文件实际上不能打印任何东西，它只调用操作系统提供的printf。

而 Rust 则不可以，Rust可执行文件会捆绑自己的标准库（300KB或更多）。幸运的是，这只是一次性的开销，可以减少。

对于嵌入式开发，可以关闭标准库，使用 "no-std"，Rust将生成 "裸 "代码。

在每个函数的基础上，Rust代码的大小与C差不多，但有一个 "泛型膨胀 "的问题。泛型函数为它们所使用的每一种类型都有优化的版本，所以有可能出现同一个函数有8个版本的情况，cargo-bloat[4] 库有助于发现这些问题。

在Rust中使用依赖关系是非常容易的。与 JS/npm 类似，现在推荐使用小型且单用途的包，但它们确实在不断增加。cargo-tree 命令对于删减它们非常有用。

Rust 略胜 C 的一些地方

1. 为了隐藏实现细节，C 库经常返回不透明的数据结构指针，并确保结构的每个实例只有一个副本。它会消耗堆分配和指针间接寻址的成本。Rust 内置的隐私、单一所有权规则和编码惯例允许库暴露其对象，而不需要间接性，这样，调用者可以决定将其放入堆（heap）上还是栈（stack）中。可以主动或彻底地优化栈上的对象。

2. 缺省情况下，Rust 可以将来自标准库、依赖项和其他编译单元的函数内联。

3. Rust 会对结构体字段进行重排，以优化内存布局。

4. 字符串携带大小信息，使得长度检查速度很快。并允许就地生成子串。

5. 与 C++ 模板类似，Rust 中泛型函数会单态化，生成不同类型的副本，因此像 sort 这样的函数和 HashMap 这样的容器总是针对相应的类型进行优化。对于 C 语言，则必须在修改宏或者处理void*和运行时变量大小的效率较低的函数之间做出选择。

6. Rust的迭代器可以组合成链状，作为一个单元一起被优化。因此，你可以调用it.buy().use().break().change().mail().upgrade()，而不是对同一个缓存区多次写入的一系列调用。

7. 同样，通过 Read 和 Write 接口，接收一些未缓存的流数据，在流中执行 CRC 校验，然后将其转码、压缩，再写入网络中，所有这些都可以在一次调用中完成。虽然 C 语言中应该也可以做到，但它没有泛型和特质（trait），将很难做到。

8. Rust 标准库中内置高质量的容器和优化过的数据结构，比 C 使用起来更方便。

9. Rust的 serde 是世界上最快的JSON解析器之一，使用体验非常棒。

Rust 比 C 明显优越的地方

主要是两点：

1. Rust 消除数据竞争，天生线程安全，解放多线程生产力，是 Rust 明显比 C / Cpp 等语言优越的地方。

2. Rust 语言支持异步高并发编程。

3. Rust 支持 安全的编译期计算。

线程安全

即使是在第三方库中，Rust 也会强制实现所有代码和数据的线程安全，哪怕那些代码的作者没有注意线程安全。一切都遵循一个特定的线程安全保证，或者不允许跨线程使用。当你编写的代码不符合线程安全时，编译器会准确地指出不安全之处。

Rust 生态中已经有了很多库，如数据并行、线程池、队列、任务、无锁数据结构等。有了这类组件的帮助，再加上类型系统强大的安全网，完全可以很轻松地实现并发/并行化 Rust 程序。有些情况下，用 par_iter 代替 iter 是可以的，只要能够进行编译，就可以正常工作！这并不总是线性加速（ 阿姆达尔定律（Amdahl's law）很残酷），但往往是相对较少的工作就能加速 2~3 倍。

延伸：阿姆达尔定律，一个计算机科学界的经验法则，因 Gene Amdahl 而得名。它代表了处理器并行计算之后效率提升的能力。

在记录线程安全方面，Rust 和 C 有一个有趣的不同。

Rust 有一个术语表用于描述线程安全的特定方面，如 Send 和 Sync、guards 和 cell。

对于 C 库，没有这样的说法：“可以在一个线程上分配它，在另一个线程上释放它，但不能同时从两个线程中使用它”。

根据数据类型，Rust 描述了线程安全性，它可以泛化到所有使用它们的函数。

对于 C 语言来说，线程安全只涉及单个函数和配置标志。

Rust 的保证通常是在编译时提供的，至少是无条件的。

对于 C 语言，常见的是“仅当 turboblub 选项设置为 7 时，这才是线程安全的”。

异步并发

Rust 语言支持 async/await异步编程模型。

该编程模型，基于一个叫做 Future 的概念，，在 JavaScript 中也叫做 Promise。Future 表示一个尚未得出的值，你可以在它被解决（resolved）以得出那个值之前对它进行各种操作。在许多语言中，对 Future 所做的工作并不多，这种实现支持很多特性比如组合器（Combinator），尤其是能在此基础上实现更符合人体工程学的 async/await 语法。

Future 可以表示各种各样的东西，尤其适用于表示异步 I/O ：当你发起一次网络请求时，你将立即获得一个 Future 对象，而一旦网络请求完成，它将返回任何响应可能包含的值；你也可以表示诸如“超时”之类的东西，“超时”其实就是一个在过了特定时间后被解决的 Future ；甚至不属于 I/O 的工作或者需要放到某个线程池中运行的CPU密集型的工作，也可以通过一个 Future 来表示，这个 Future 将会在线程池完成工作后被解决。

Future 存在的问题 是它在大多数语言中的表示方式是这种基于回调的方法，使用这种方式时，你可以指定在 Future 被解决之后运行什么回调函数。也就是说， Future 负责弄清楚什么时候被解决，无论你的回调是什么，它都会运行；而所有的不便也都建立在此模型上，它非常难用，因为已经有很多开发者进行了大量的尝试，发现他们不得不写很多分配性的代码以及使用动态派发；实际上，你尝试调度的每个回调都必须获得自己独立的存储空间，例如 crate 对象、堆内存分配，这些分配以及动态派发无处不在。这种方法没有满足零成本抽象的第二个原则，如果你要使用它，它将比你自己写要慢很多，那你为什么还要用它。

Rust 中的方案有所不同。不是由 Future 来调度回调函数，而是由一个被称为执行器（executor）的组件去轮询 Future。而 Future 可能返回“尚未准备就绪（Pending）”，也可能被解决就返回“已就绪（Ready）”。该模型有很多优点。其中一个优点是，你可以非常容易地取消 Future ，因为取消 Future 只需要停止持有 Future。而如果采用基于回调的方法，要通过调度来取消并使其停止就没这么容易了。

同时它还能够使我们在程序的不同部分之间建立真正清晰的抽象边界，大多数其他 Future 库都带有事件循环（event loop），这也是调度 你的Future 执行 I/O 的方法，但实际上你对此没有任何控制权。

而在 Rust 中，各组件之间的边界非常整洁，执行器（executor）负责调度你的 Future ，反应器（reactor）处理所有的 I/O ，然后是你的实际代码。因此最终用户可以自行决定使用什么执行器，使用他们想使用的反应器，从而获得更强的控制力，这在系统编程语言中真的很重要。

而此模型最重要的真正优势在于，它使我们能够以一种真正零成本的完美方式实现这种状态机式的 Future 。也就是当你编写的 Future 代码被编译成实际的本地（native）代码时，它就像一个状态机；在该状态机中，每次 I/O 的暂停点都有一个变体（variant），而每个变体都保存了恢复执行所需的状态。

而这种 Future 抽象的真正有用之处在于，我们可以在其之上构建其他 API 。可以通过将这些组合器方法应用于 Future 来构建状态机，它们的工作方式类似于迭代器（Iterator）的适配器（如 filter、map）。但是这种方式是有一些缺点的，尤其是诸如嵌套回调之类，可读性非常差。所以才需要实现 async / await异步语法。

目前 Rust 生态中，已经有了成熟的 tokio[5] 运行时生态，支持 epoll 等异步 I/O。如果你想用 io_uring ，也可以使用 Glommio[6] ，或者等待 tokio 对 io_uring 的支持。甚至，你可以使用 smol 运行时提供的 async_executor[7] 和 async-io[8] 来构建你自己的运行时。

编译期计算

Rust 可以支持类似于 Cpp 那样的 编译期常量求值。这一点是明显比C优越的。

虽然目前功能还不如 Cpp 那样强大，但还在不断的维护中。

为什么 Rust 中支持 编译期计算这么谨慎呢？因为Rust 编译期求值是必须要保证安全的，所以有很多考虑。Rust 编译期求值不像 Cpp 那样自由且容易滥用。

可靠性

2020 年 6月份，来自3所大学的5位学者在ACM SIGPLAN国际会议（PLDI'20）上发表了一篇研究成果，针对近几年使用Rust语言的开源项目中的安全缺陷进行了全面的调查。这项研究调查了5个使用Rust语言开发的软件系统，5个被广泛使用的Rust库，以及两个漏洞数据库。调查总共涉及了850处unsafe代码使用、70个内存安全缺陷、100个线程安全缺陷。

 

在调查中，研究员不光查看了所有漏洞数据库中报告的缺陷和软件公开报告的缺陷，还查看了所有开源软件代码仓库中的提交记录。通过人工的分析，他们界定出提交所修复的BUG类型，并将其归类到相应的内存安全/线程安全问题中。所有被调查过的问题都被整理到了公开的Git仓库中：https://github.com/system-pclub/rust-study[9]

调查结果说明：

1.  

   Rust语言的safe代码对于空间和时间内存安全问题的检查非常有效，所有稳定版本中出现的内存安全问题都和unsafe代码有关。

2.  

   虽然内存安全问题都和unsafe代码有关，但大量的问题同时也和safe代码有关。有些问题甚至源于safe代码的编码错误，而不是unsafe代码。

3.  

   线程安全问题，无论阻塞还是非阻塞，都可以在safe代码中发生，即使代码完全符合Rust语言的规则。

4.  

   大量问题的产生是由于编码人员没有正确理解Rust语言的生命周期规则导致的。

5.  

   有必要针对Rust语言中的典型问题，建立新的缺陷检测工具。

那么这份调查报告背后 Rust 的安全性是如何保证的呢？Unsafe Rust 又是为什么 Unsafe 呢？

所有权：Rust 语言内存安全机制

Rust 的设计深深地吸取了关于安全系统编程的学术研究的精髓。特别是，与其他主流语言相比，Rust 设计的最大特色在于采用了所有权类型系统（在学术文献中通常称为仿射或子结构类型系统36[10]）。

所有权机制，就是Rust 语言借助类型系统，承载其“内存安全”的思想，表达出来的安全编程语义和模型。

所有权机制要解决的内存不安全问题包括：

1.  

   引用空指针。

2.  

   使用未初始化内存。

3.  

   释放后使用，也就是使用悬垂指针。

4.  

   缓冲区溢出，比如数组越界。

5.  

   非法释放已经释放过的指针或未分配的指针，也就是重复释放。

注意，内存泄露不属于内存安全问题范畴，所以 Rust 也不解决内存泄露问题。

为了保证内存安全，Rust 语言建立了严格的安全内存管理模型：

• 所有权系统。每个被分配的内存都有一个独占其所有权的指针。只有当该指针被销毁时，其对应的内存才能随之被释放。

• 借用和生命周期。每个变量都有其生命周期，一旦超出生命周期，变量就会被自动释放。如果是借用，则可以通过标记生命周期参数供编译器检查的方式，防止出现悬垂指针，也就是释放后使用的情况。

其中所有权系统还包括了从现代 C++ 那里借鉴的 RAII 机制，这是 Rust 无 GC 但是可以安全管理内存的基石。

建立了安全内存管理模型之后，再用类型系统表达出来即可。Rust 从 Haskell 的类型系统那里借鉴了以下特性：

• 没有空指针

• 默认不可变

• 表达式

• 高阶函数

• 代数数据类型

• 模式匹配

• 泛型

• trait 和关联类型

• 本地类型推导

为了实现内存安全，Rust 还具备以下独有的特性：

• 仿射类型（Affine Type），该类型用来表达 Rust 所有权中的 Move 语义。

• 借用、生命周期。

借助类型系统的强大，Rust 编译器可以在编译期对类型进行检查，看其是否满足安全内存模型，在编译期就能发现内存不安全问题，有效地阻止未定义行为的发生。

内存安全的 Bug 和并发安全的 Bug 产生的内在原因是相同的，都是因为内存的不正当访问而造成的。同样，利用装载了所有权的强大类型系统，Rust 还解决了并发安全的问题。Rust 编译器会通过静态检查分析，在编译期就检查出多线程并发代码中所有的数据竞争问题。

Unsafe Rust ：划分安全边界

为了和现有的生态系统良好地集成，Rust 支持非常方便且零成本的 FFI 机制，兼容 C-ABI，并且从语言架构层面上将 Rust 语言分成 Safe Rust 和 Unsafe Rust 两部分。

其中 Unsafe Rust 专门和外部系统打交道，比如操作系统内核。之所以这样划分，是因为 Rust 编译器的检查和跟踪是有能力范围的，它不可能检查到外部其他语言接口的安全状态，所以只能靠开发者自己来保证安全。

Rust 的最终目标并不是完全消除那些危险点，因为在某种程度上，我们需要能够访问内存和其他资源。实际上，Rust 的目标是将所有的unsafe元素抽象出来。在考虑安全性时，你需要考虑“攻击面”，或者我们可以与程序的哪些部分进行交互。像解析器这样的东西是一个很大的攻击面，因为：

•  

  它们通常可以被攻击者访问；

•  

  攻击者提供的数据可以直接影响解析通常需要的复杂逻辑。

  你可以进一步分解，将传统的攻击面分解成“攻击面”（可以直接影响程序代码的部分）和“安全层”，这部分代码是攻击面依赖的代码，但是无法访问，而且可能存在潜在的 Bug。在 C 语言中，它们是一样的：C 语言中的数组根本不是抽象的，所以如果你读取了可变数量的项，就需要确保所有的不变量都保持不变，因为这是在不安全层中操作，那里可能会发生错误。

所以，Rust 提供了 unsafe 关键字和unsafe块，显式地将安全代码和访问外部接口的不安全代码进行了区分，也为开发者调试错误提供了方便。Safe Rust 表示开发者将信任编译器能够在编译时保证安全，而 Unsafe Rust 表示让编译器信任开发者有能力保证安全。

有人的地方就有 Bug。Rust 语言通过精致的设计，将机器可以检查控制的部分都交给编译器来执行，而将机器无法控制的部分交给开发者自己来执行。

Safe Rust 保证的是编译器在编译时最大化地保障内存安全，阻止未定义行为的发生。

Unsafe Rust 用来提醒开发者，此时开发的代码有可能引起未定义行为，请谨慎！人和编译器共享同一个“安全模型”，相互信任，彼此和谐，以此来最大化地消除人产生 Bug 的可能。

Unsafe Rust，是Rust的安全边界。世界的本质就是Unsafe的。你无法避免它。还有人说，因为Unsafe Rust的存在，所以也不见得能比C/C++安全到哪里去？Unsafe Rust确实和C/C++一样，要靠人来保证它的安全。但它对人的要求更高。

它也给了开发者一个Unsafe的边界，这其实也是一种安全边界。它把你代码里的雷区，显式地标记了出来。团队代码里review的话，可以更快地发现问题。这本身就是一种安全。而反观C++，你写出的每一行代码都是Unsafe的，因为它没有像Rust这样明显的界限（Unsafe 块）。

以下是我总结的五条使用Unsafe的简单规范，方便大家做权衡：

1. 能用Safe Rust就用Safe Rust；

2. 为了性能可以使用Unsafe Rust；

3. 在使用Unsafe Rust的时候确保不要产生UB，并且尽量判断其安全边界，抽象为 Safe 方法；

4. 如果无法抽象为Safe，需要标注为Unsafe，并配以产生UB的条件文档；

5. 对于Unsafe的代码，大家可以重点review。

所以，Unsafe 使用不当也会引发内存安全或逻辑 Bug 。所以，学习 如何对 Unsafe Rust 进行安全抽象至关重要。

不过，Rust 社区生态中有一个 Rust 安全工作组，该组提供 cargo-audit等一系列工具[11]，并且维护`RustSecurity` 安全数据库库[12]中记录的Rust生态社区中发现的安全问题。可以方便地检查 Rust 项目中依赖库的安全问题。

生产力

编程语言生产力，大概可以通过以下三个方面来评估：

1. 学习曲线。

2. 语言工程能力。

3. 领域生态。

学习曲线

学习曲线的高低，依个人水平不同而不同。以下罗列了不同基础学习 Rust 应该注意的地方。

1.  

   完全零基础的开发者：掌握计算机基础体系知识结构，理解Rust语言和硬件/OS层的抽象，理解Rust语言核心概念、以及它的抽象模式，选择Rust语言的某个适用领域进行实操训练，通过实践来提升Rust语言的熟练度和理解深度，同时掌握领域知识。

2.  

   有C语言基础：由于C语言开发者对高级语言的抽象不是很理解，所以着重了解掌握Rust所有权机制，包括所有权的语义，生命周期和借用检查。了解Rust语言的抽象模式，主要是类型和trait；以及Rust本身的的OOP和函数式语言特性。

3.  

   有C++基础：C++开发者对于Rust语言的所有权有很好的理解能力，主要精力放在Rust的抽象模式和函数式语言特性上。

4.  

   有Java/Python/Ruby基础：着重理解攻克Rust所有权机制、抽象模式、函数式编程语言特性。

5.  

   有Go基础：Go语言开发者比较容易理解Rust的类型和trait抽象模式，但Go也是GC语言，所以所有权机制和函数式语言特性是他们的学习重点。

6.  

   有Haskell基础：Haskell系的开发者对Rust语言函数式特性能很好的理解，主要攻克所有权机制和OOP语言特性。

所以，对于有一定基础的开发者来说，学习Rust语言要掌握的几个关键概念有：

1、Rust所有权机制，包括所有权的语义，生命周期和借用检查

所有权机制是Rust语言最核心的特性，它保证了在没有垃圾回收机制下的内存安全，所以对于习惯了GC的开发者，理解Rust的所有权是最关键的一环，切记这三点：

• Rust中的每一个值都有一个被称为其所有者 (owner)的变量。

• 值有且只有一个所有者。

• 当所有者（变量）离开作用域，这个值将被丢弃。这其中又涉及到生命周期和借用检查等概念，是相对比较难啃的一块硬骨头。

2、Rust语言的抽象模式，主要是类型和trait。trait借鉴了Haskell中的Typeclass，它是对类型行为的抽象，可以通俗地类比为其他编程语言里的接口，它告诉编译器一个类型必须提供哪些功能语言特性。使用时要遵循一致性，不能定义相互冲突的实现。

3、OOP语言特性。熟悉面向对象编程（OOP）的常见的四个特性：对象、封装、继承和多态，可以更好地理解Rust的一些特性，比如impl、pub、trait等等。

4、函数式语言特性。Rust语言的设计深受函数式编程的影响，看到函数式特性，数学不好的人可能会望而却步，因为函数式编程语言的最大特点是把运算过程尽量写成一系列嵌套的函数调用,在Rust中，掌握闭包和迭代器是编写函数式语言风格的高性能Rust代码的重要一环。

语言工程能力

Rust 已经为开发工业级产品做足了准备。

为了保证安全性，Rust 引入了强大的类型系统和所有权系统，不仅保证内存安全，还保证了并发安全，同时还不会牺牲性能。

为了保证支持硬实时系统，Rust 从 C++那里借鉴了确定性析构、RAII 和智能指针，用于自动化地、确定性地管理内存，从而避免了 GC 的引入，因而就不会有“世界暂停”的问题了。这几项虽然借鉴自 C++，但是使用起来比 C++更加简洁。

为了保证程序的健壮性，Rust 重新审视了错误处理机制。日常开发中一般有三类非正常情况：失败、错误和异常。但是像 C 语言这种面向过程的语言，开发者只能通过返回值、goto 等语句进行错误处理，并且没有统一的错误处理机制。而 C++和 Java 这种高级语言虽然引入了异常处理机制，但没有专门提供能够有效区分正常逻辑和错误逻辑的语法，而只是统一全局进行处理，导致开发者只能将所有的非正常情况都当作异常去处理，这样不利于健壮系统的开发。并且异常处理还会带来比较大的性能开销。

Rust 语言针对这三类非正常情况分别提供了专门的处理方式，让开发者可以分情况去选择。

• 对于失败的情况，可以使用断言工具。

• 对于错误，Rust 提供了基于返回值的分层错误处理方式，比如 Option 可以用来处理可能存在空值的情况，而 Result 就专门用来处理可以被合理解决并需要传播的错误。

• 对于异常，Rust 将其看作无法被合理解决的问题，提供了线程恐慌机制，在发生异常的时候，线程可以安全地退出。

通过这样精致的设计，开发者就可以从更细的粒度上对非正常情况进行合理处理，最终编写出更加健壮的系统。

为了提供灵活的架构能力，Rust 使用 特质（trait） 来作为零成本抽象的基础。特质 面向组合而非继承，让开发者可以灵活地架构 紧耦合 和 松耦合的系统。Rust 也提供了 泛型 来表达类型抽象，结合 trait 特性，让 Rust 拥有静态多态 和 代码复用 的能力。泛型和trait 让你可以灵活使用各种设计模式来对系统架构进行重塑。

为了提供强大的语言扩展能力和开发效率，Rust 引入了基于宏的元编程机制。Rust提供了两种宏，分别是声明宏和过程宏。声明宏的形式和C的宏替换类似，区别在于Rust会对宏展开后的代码进行检查，在安全方面更有优势。过程宏则让 Rust 在代码复用、代码生成拥有强大的能力。

为了和现有的生态系统良好地集成，Rust 支持非常方便且零成本的 FFI 机制，兼容 C-ABI，并且从语言架构层面上将 Rust 语言分成 Safe Rust 和 Unsafe Rust 两部分。其中 Unsafe Rust 专门和外部系统打交道，比如操作系统内核。之所以这样划分，是因为 Rust 编译器的检查和跟踪是有能力范围的，它不可能检查到外部其他语言接口的安全状态，所以只能靠开发者自己来保证安全。Unsafe Rust 提供了 unsafe 关键字和 unsafe 块，显式地将安全代码和访问外部接口的不安全代码进行了区分，也为开发者调试错误提供了方便。Safe Rust 表示开发者将信任编译器能够在编译时保证安全，而 Unsafe Rust 表示让编译器信任开发者有能力保证安全。

有人的地方就有 Bug。Rust 语言通过精致的设计，将机器可以检查控制的部分都交给编译器来执行，而将机器无法控制的部分交给开发者自己来执行。Safe Rust 保证的是编译器在编译时最大化地保障内存安全，阻止未定义行为的发生。Unsafe Rust 用来提醒开发者，此时开发的代码有可能引起未定义行为，请谨慎！人和编译器共享同一个“安全模型”，相互信任，彼此和谐，以此来最大化地消除人产生 Bug 的可能。

为了让开发者更方便地相互协作，Rust 提供了非常好用的包管理器Cargo[13]。Rust 代码是以包（crate）为编译和分发单位的，Cargo 提供了很多命令，方便开发者创建、构建、分发、管理自己的包。Cargo 也提供插件机制，方便开发者编写自定义的插件，来满足更多的需求。比如官方提供的 rustfmt 和 clippy 工具，分别可以用于自动格式化代码和发现代码中的“坏味道”。再比如，rustfix 工具甚至可以帮助开发者根据编译器的建议自动修复出错的代码。Cargo 还天生拥抱开源社区和 Git，支持将写好的包一键发布到 crates.io 网站，供其他人使用。

为了方便开发者学习 Rust，Rust 官方团队做出了如下努力：

• 独立出专门的社区工作组，编写官方 Rust Book，以及其他各种不同深度的文档，比如编译器文档、nomicon book 等。甚至组织免费的社区教学活动 Rust Bridge，大力鼓励社区博客写作，等等。

• Rust 语言的文档支持 Markdown 格式，因此 Rust 标准库文档表现力丰富。生态系统内很多第三方包的文档的表现力也同样得以提升。

• 提供了非常好用的在线 Playground 工具，供开发者学习、使用和分享代码。

• Rust 语言很早就实现了自举，方便学习者通过阅读源码了解其内部机制，甚至参与贡献。

• Rust 核心团队一直在不断改进 Rust，致力于提升 Rust 的友好度，极力降低初学者的心智负担，减缓学习曲线。比如引入 NLL 特性来改进借用检查系统，使得开发者可以编写更加符合直觉的代码。

• 虽然从 Haskell 那里借鉴了很多类型系统相关的内容，但是 Rust 团队在设计和宣传语言特性的时候，会特意地去学术化，让 Rust 的概念更加亲民。

• 在类型系统基础上提供了混合编程范式的支持，提供了强大而简洁的抽象表达能力，极大地提升了开发者的开发效率。

• 提供更加严格且智能的编译器。基于类型系统，编译器可以严格地检查代码中隐藏的问题。Rust 官方团队还在不断优化编译器的诊断信息，使得开发者可以更加轻松地定位错误，并快速理解错误发生的原因。

为了方便 Rust 开发者提升开发效率，Rust 社区还提供了强大的 IDE 支持。VSCode/Vim/Emacs + Rust Analyzer 成为了 Rust 开发的标配。当然 JetBrains家族的 IDEA/ Clion 也对 Rust 支持十分强力。

Rust 与 开源

Rust 语言自身作为一个开源项目，也是现代开源软件中的一颗璀璨的明珠。

在 Rust 之前诞生的所有语言，都仅仅用于商用开发，但是 Rust 语言改变了这一状况。对于 Rust 语言来说，Rust 开源社区也是语言的一部分。同时，Rust 语言也是属于社区的。

Rust 团队由 Mozilla 和非 Mozilla 成员组成，至今 Rust 项目贡献者已经超过了 1900 人。Rust 团队分为核心组和其他领域工作组，针对 Rust 2018 的目标，Rust 团队被分为了嵌入式工作组、CLI 工作组、网络工作组以及 WebAssembly 工作组，另外还有生态系统工作组和社区工作组等。

这些领域中的设计都会先经过一个 RFC 流程，对于一些不需要经过 RFC 流程的更改，只需要给 Rust 项目库提交 Pull Request 即可。所有过程都是对社区透明的，并且贡献者都可参与评审，当然，最终决策权归核心组及相关领域工作组所有。后面为了精简 FCP流程，也引入了 MCP。

Rust 团队维护三个发行分支：稳定版（Stable）、测试版（Beta）和开发版（Nightly）。其中稳定版和测试版每 6 周发布一次。标记为不稳定（Unstable）和特性开关（Feature Gate）的语言特性或标准库特性只能在开发版中使用。

在 Rust 基金会成立以后，Rust 团队也在不断探索新的开源治理方案。

Rust 语言的不足

Rust 虽然有很多优势，但肯定也存在一些缺点。

1. Rust 编译速度很慢。虽然 Rust 官方也一直在改进 Rust 编译速度，包括增量编译支持，引入新的编译后端（ cranelift ），并行编译等措施，但还是慢。而且 增量编译目前也有 Bug。

2. 学习曲线陡峭。

3. IDE 支持不够完善。比如，对宏代码的支持不是很好。

4. 缺乏针对 Rust 语言特有内存不安全问题的各种检测工具。

Rust 生态基础库和工具链

Rust 生态日趋丰富，很多基础库和框架都会以 包（crate） 的方式发布到 crates.io[14] ，截至目前，crates.io 上面已经有 62981 个 crate，总下载量已经达到 7,654,973,261次。

按包的使用场景分类，Crates.io 最流行的几个场景依次如下：

• 命令行工具 （3133 crates）

• no-std 库 （2778 crates）

• 开发工具（测试/ debug/linting/性能检测等， 2652 crates）

• Web 编程 （1776 crates）

• API 绑定 （方便 Rust 使用的特定 api 包装，比如 http api、ffi 相关api等，1738 crates）

• 网络编程 （1615 crates）

• 数据结构 （1572 crates）

• 嵌入式开发 （1508 crates）

• 加密技术（1498 crates）

• 异步开发（1487 crates）

• 算法 （1200 crates）

• 科学计算（包括物理、生物、化学、地理、机器学习等，1100 crates）

除此之外，还有 WebAssembly 、编码、文本处理、并发、GUI、游戏引擎、可视化、模版引擎、解析器、操作系统绑定 等其他分类，也有不少库。

常用知名基础库和工具链

其中已经涌现出不少优秀的基础库，都可以在 crates.io 首页里看到。这里罗列出一些：

•  

  序列化/反序列化：Serde[15]

•  

  命令行开发：clap [16]/ structopt[17]

•  

  异步/Web/网络开发：tokio [18] / tracing [19] /async-trait [20] / tower [21]/ async-std [22] tonic [23]/ actix-web [24]/smol [25]/ surf [26]/ async-graphql [27]/ warp /[28] tungstenite [29]/ encoding_rs [30]/ loom [31]/ Rocket[32]

•  

  FFi 开发：libc [33]/ winapi [34]/ bindgen [35]/ pyo3 [36]/ num_enum [37]/ jni [38]/ rustler_sys[39]/ cxx [40]/ cbindgen [41]/ autocxx-bindgen [42]

•  

  API 开发: jsonwebtoken [43]/ validator [44]/ tarpc [45]/ nats [46]/ tonic[47]/ protobuf [48]/ hyper [49]/ httparse [50]/ reqwest [51] / url [52]

•  

  解析器：nom [53]/ pest [54]/ csv [55]/ combine [56]/ wasmparser [57]/ ron [58]/ lalrpop [59]

•  

  密码学：openssl [60]/ ring [61]/ hmac [62]/ rustls[63] / orion[64] / themis[65] / RustCrypto[66]

•  

  WebAssembly: wasm-bindgen[67]/ wasmer [68]/ wasmtime [69]/ yew [70]

•  

  数据库开发：diesel [71]/ sqlx [72]/ rocksdb [73]/ mysql [74]/ elasticsearch [75]/ rbatis [76]

•  

  并发：crossbeam [77]/ parking_lot [78]/ crossbeam-channel [79]/ rayon [80]/ concurrent-queue[81]/ threadpool [82] / flume [83]

•  

  嵌入式开发：embedded-hal [84]/ cortex-m [85]/ bitvec [86]/ cortex-m-rtic [87]/ embedded-dma [88]/ cross [89]/ Knurling Tools[90]

•  

  测试：static_assertions [91]/ difference [92]/ quickcheck [93]/ arbitrary [94]/ mockall [95]/ criterion [96]/ proptest[97] / tarpaulin[98]/ fake-rs[99]

•  

  多媒体开发：rust-av[100]/ image[101]/ svg [102]/ rusty_ffmpeg[103]/ Symphonia[104]/

•  

  游戏引擎和基础组件：glam [105]/ sdl2 [106]/ bevy [107]/ amethyst[108]/ laminar[109]/ ggez [110]/ tetra[111]/ hecs[112]/ simdeez[113]/ rg3d [114] / [rapier](https://github.com/dimforge/ra pier "rapier") / Rustcraft[115] Nestadia[116]/ naga[117]/ Bevy Retro[118]/ Texture Generator[119] / building_blocks[120] / rpg-cli [121]/ macroquad[122]

•  

  TUI/GUI 开发：winit [123]/ gtk [124]/ egui [125]/ imgui [126]/ yew [127]/ cursive [128]/ iced [129]/ fontdue [130]/ tauri [131]/ druid [132]

Rust 行业应用盘点

Rust 是一门通用的高级系统级编程语言，其应用领域基本可以同时覆盖 C/Cpp/Java/Go/Python 的应用领域。

具体而言，Rust 的应用领域目前覆盖到以下领域：

下面来盘点不同领域内国内外的 Rust 项目。通过提供代码量、团队规模、项目周期相关数据，希望可以让大家对 Rust 领域应用和开发效率能有一个比较直观的认识。

数据服务

数据服务领域，包括了数据库，数据仓储，数据流，大数据等。

TiKV（国内/开源/分布式数据库）

关键字：数据库/ 分布式系统/ CNCF

介绍

TiKV [133]是一个开源的分布式事务 Key-Value 数据库，专注为下一代数据库提供可靠、高质量、实用的存储架构。最初由 PingCAP 团队在 目前，TiKV 已经在知乎、一点资讯、Shopee、美团、京东云、转转等多行业头部企业得到上线应用。

TiKV 通过 Raft 一致性算法来实现数据多副本之间的一致性，本地采用了 RocksDB 存储引擎存储数据，同时 TiKV 支持数据自动切分和迁移。TiKV 的跨行事务最初参考 Google Percolator 事务模型，并进行了一些优化，提供快照隔离与带锁快照隔离，支持分布式事务。

2018 年 8 月被 CNCF 宣布接纳为沙箱云原生项目，在 2019 年 5 月从沙箱晋级至孵化项目。

代码与团队规模

TiKV 项目 包含 Rust 代码行数大约 30 万行（包含测试代码）。

TiKV 是全球性开源项目，可以从贡献者名单[134]来查看团队规模。TiKV 组织中也包含了一些 Go/Cpp 项目，这个并不算在内，只统计参与 Rust 项目的人力规模。

• 主力开发：20人左右。

• 社区贡献：300 多人。

项目周期

TiKV 是作为 TiDB 的底层存储跟随 TiDB 演进。TiDB 为 Go 开发，TiKV 为 Rust 开发。

2016 年 1 月作为 TiDB 的底层存储引擎设计并开发 。

2016 年 4 月开源 发布第一版。

2017 年 10 月 16 日，TiDB 发布 GA 版（TiDB 1.0）， TiKV 发布 1.0 。

2018 年 4 月 27 日，TiDB 发布 2.0 GA 版， TiKV 发布 2.0 。

2019 年 6 月 28 日，TiDB 发布 3.0 GA 版本， TiKV 发布 3.0 。

2020 年 5 月 28 日，TiDB 发布 4.0 GA 版本， TiKV 发布 4.0。

2021 年 4 月 07 日，TiDB 发布 5.0 GA 版本， TiKV 发布 5.0。

小评

有些朋友可能比较关注 Rust 开发效率如何，并且想对其量化，尤其是想对比 C/ Cpp / Go 等其他语言的开发效率。

私以为量化开发效率是非常困难的，尤其是和其他语言比较的量化。我们不妨换个角度来看这件事，比如，从敏捷项目迭代管理来看这件事。如果一门语言，可以满足日常的敏捷开发迭代需求，可以帮助完成产品的进化，那足以说明这门语言的开发效率了。

据了解，PingCAP 中 Go 开发人员是 Rust 开发人员的四五倍之多，当然工作量也差不多是这样的比例。从上面的数据，我们可以看得出来， Rust 项目（TiKV）依然可以稳步跟得上 Go 项目（TiDB）的迭代节奏，说明 Rust 的开发效率还是足以胜任现代化开发需求。

TensorBase （国内/开源/实时数据仓库）

关键字：实时数据仓库/ 创业/ 天使轮

介绍

TensorBase[135] 是金明剑博士于 2020 年 8月启动的创业项目，从一个现代的全新视角出发，用开源的文化和方式，重新构建一个Rust下的实时数据仓库，服务于这个海量数据时代的数据存储和分析。TensorBase 项目目前已获得世界知名创业投资加速机构的天使轮投资。

代码与团队规模

因为 TensorBase 是构建于 Apache Arrow[136] 和 Arrow DataFusion[137] 之上，所以代码统计排除掉这两个项目的依赖。

TensorBase 核心代码行数 54000 多行。

团队规模：

• 主力开发：1人。

• 社区贡献：13 人。

因为是新项目，开源社区还在建设中。

项目周期

TensorBase 以时间为节奏发版，而非语义版。迭代周期预计 一年一个大版本，一月一个小版本。

从 2021年 4 月 20 正式发版，到最近 6月 16，保持这个节奏。

Timely Dataflow (国外/开源/实时数据流)

关键字：Dataflow/ 分布式系统/创业

介绍

Timely Dataflow[138] 是 基于微软 这篇 Timely Dataflow 论文：《Naiad: A Timely Dataflow System》[139]的 现代化 Rust 实现。是 clockworks.io[140] 公司的开源产品。

在分布式系统中对流式数据进行复杂的处理，比如多次迭代或者递增计算是非常困难的。Storm, Streaming Spark, MillWheel 都不能很好的适应各种应用复杂的需求。Naiad 通过引入 timestamp 的概念，给出了一个非常 low-level 的模型，可以用来描述任意复杂的流式计算。

dataflow系统包罗万象，MapReduce，Spark都可以算是其中代表。Timely dataflow 给出了一个完全基于时间的抽象，统一了流式计算和迭代计算。当你需要对流式数据并行处理且需要迭代控制的时候，可以使用 Timely Dataflow 。

代码与团队规模

Rust 代码量 大约 13000 行。

团队规模：

• 主力开发：4人。

• 社区贡献：30多人。

项目周期

2017年9月7号，0.3.0 版本。

2018年6月28号，0.6.0 版本。

2018年9月16号，0.7.0 版本。

2018年12月3号，0.8.0 版本。

2019年3月31号，0.9.0 版本。

2019年7月10号，0.10.0 版本。

2021年3月10号，0.12.0版本。

基本上 三个月 出 一个 小版本，除了 Timely Dataflow 之外该团队同时还维护一个构建于 Timely Dataflow 之上的 Differential Dataflow[141] ，和 Timely Dataflow 同步迭代。

Noria （国外/学术研究/开源/数据库）

关键字：数据库/ 学术论文项目

介绍

Noria [142] 是一种新的流式数据流系统，旨在作为基于MIT Jon Gjengset[143] 的博士学位论文[144]的重型Web应用程序的快速存储后端，也参考了OSDI'18的论文[145]。它类似于数据库，但支持预计算和缓存关系查询结果，以便加速查询。Noria 自动将缓存的结果保持为底层数据，存储在持久性基础表中。Noria使用部分状态数据流来减少内存开销，并支持动态，运行时数据流和查询更改。

代码与团队规模

Rust 代码行数大约 59000 多行。

团队规模：

• 主力贡献者：2人

• 社区贡献者：21人

项目周期

因为是个人学术研究项目，所以发布周期没有那么明显。

项目周期 2016年7月30 ~ 2020年 4月30，一共5000多commit。

Vector （国外/开源/数据管道）

关键字：数据管道/分布式系统/创业

Vector[146] 是 Timer 公司构建的一款高性能的、端到端的（代理和聚合器）可观察性数据管道。它是开源的，比该领域（Logstash、Fluentd之类）的所有替代方案快10倍。目前像 豆瓣、checkbox.ai、fundamentei、BlockFi、Fly.io 等公司使用了 Vector 。点击此处[147]查看官方性能报告，点击此处[148]查看目前生产环境中使用 Vector 的公司。

代码与团队规模

代码量大约 18 万行 Rust 代码。

团队规模：

• 主力开发：9人

• 社区贡献：140 人

项目周期

2019年3月22，初始版本发布。

2019年6月10，0.2.0版本发布

2019年7月2，0.3.0版本发布

2019年9月25，0.4.0版本发布

2019年10月11，0.5.0版本发布

2019年12月13，0.6.0版本发布

2020年1月12，0.7.0版本发布

2020年2月26，0.8.0版本发布

2020年4月21，0.9.0版本发布

2020年7月23，0.10.0版本发布

2021年3月12，0.11.0 ～ 0.12 版本发布

2021年4月22，0.13.0版本发布

2021年6月3，0.14.0版本发布

Arrow-rs （国外/开源/大数据标准）

关键字：大数据/数据格式标准/Apach

arrow-rs[149] 是 Apache Arrow 的 Rust 实现。Apache Arrow 是 一种适合异构大数据系统的内存列存数据格式标准。它有一个非常大的愿景：提供内存数据分析 (in-memory analytics) 的开发平台，让数据在异构大数据系统间移动、处理地更快。

Arrow 从 2.0 版本开始引入 Rust[150] ，从 4.0 开始 Rust 实现迁移到了独立仓库 arrow-rs 。

Arrow的Rust实现实际上由几个不同的项目组成，包括以下几个独立 crate 和 库 ：

• arrow[151]，arrow-rs 核心库，包含在 arrow-rs 中。

• arrow-flight [152]，arrow-rs 组件之一，包含在 arrow-rs 中。

• parquet[153]，arrow-rs 组件之一，包含在 arrow-rs 中。在大数据生态内，Parquet 是最为流行的文件存储格式。

• DataFusion[154]，一个可扩展的内存查询执行引擎，使用Arrow作为其格式。

• Ballista[155]，一个分布式计算平台，由Apache Arrow和DataFusion驱动，包含在 DataFusion 中。

代码与团队规模

arrow-rs 各相关组件加起来，Rust 代码量 大约 18 万行。

团队规模：

•  

  主力开发：大约 10 人

•  

  社区贡献：550 多人

项目周期

项目 DataFusion 在 2016 年就开始构建了，后来进入了 Apache Arrow 项目。

以 arrow-rs 4.0 开始算：

2021 年 4 月 18 ，版本 4.0 发布。

2021 年 5 月 18，版本 4.1 发布。

2021 年 5 月 30， 版本 4.2 发布。

2021 年 6 月11， 版本 4.3 发布。

InfluxDB IOx （国外/ 开源/时序数据库）

关键字：时序数据库/分布式

InfluxDB IOx[156]，是 InfluxDB 的下一代时序引擎，使用 Rust + Aarow 来重写。

现有设计主要有以下几个致命性问题：

1. 无法解决时间线膨胀的问题

2. 在云原生环境下，对内存管理要求比较严格，这意味 mmap 不在适用，而且 InfluxDB 需要支持无本地盘的运行模式

3. 由于索引与数据分开存储，导致高效的数据导入导出功能难以实现

上述这三个问题都是现有设计的核心之处，因此要想支持现阶段需求，重写是个比较好的选择。

代码与团队规模

InfluxDB IOx 代码量大约是 16万行 Rust 代码。

团队规模：

• 主力开发：5人

• 社区贡献：24 人

项目周期

该项目从 2019年 11月开始立项，但截至到今天此项目还非常早期，它还没有准备好进行测试，也没有任何构建或文档。

但是从 GitHub 活动状态来看，开发状态还非常积极。主要的开发工作都是在2021年开始的。

CeresDB （国内/商业/时序数据库）

关键字：时序数据库

介绍

CeresDB 是蚂蚁集团研发的一款TP/AP 融合时序数据库，满足金融时序、监控、IOT 等场景下的海量时序数据的存储、多维查询下钻和实时分析需求。有开源计划，但目前暂未开源。

团队规模

目前数据库开发大约 8-10个人。

其他信息还未可知。

tantivy (国外/开源/全文检索)

关键字：全文检索/ lucene

tantivy[157] 是一个由 Apache Lucene 启发的全文搜索引擎库，用 Rust 实现。

tantivy 性能卓越，这里有一个基于 Rust + Tantivy + AWS 构建的应用 ：提供十亿网页搜索并生成常见单词云[158]。

代码及团队规模

代码量大约为 50000 行 Rust 代码。

团队规模：

• 主力开发：1 人

• 社区贡献：85人

项目周期

项目自 2016 年立项，迭代周期为平均一月一个小版本发布，目前发布到 0.15.2 版本。

Rucene （国内/开源/搜索引擎）

关键字：知乎/ lucene

介绍

Rucene[159] 是知乎团队开源的一款基于 Rust 实现的搜索引擎。Rucene不是完整的应用程序，而是可以轻松用于将完整文本搜索功能添加到应用程序的代码库和API。它是对 Apache Lucene 6.2.1 项目的 Rust 移植。

代码及团队规模

代码量大约为 10 万 行 Rust 代码。

团队规模：

• 主力开发：4人

• 社区贡献：0 人

项目周期

可能因为是公司内部项目开源化，目前没有迭代出具体语义版本。在知乎内是用于生产环境的。

云原生

云原生领域包括：机密计算、Serverless、分布式计算平台、容器、WebAssembly、运维工具等

StratoVirt （国内/开源/容器）

关键字：容器/ 虚拟化/ Serverless

StratoVirt[160] 是 华为 OpenEuler 团队研发的 基于Rust的下一代虚拟化平台。

Strato，取自stratosphere，意指地球大气层中的平流层，大气层可以保护地球不受外界环境侵害，而平流层则是大气层中最稳定的一层；类似的，虚拟化技术是操作系统平台之上的隔离层，既能保护操作系统平台不受上层恶意应用的破坏，又能为正常应用提供稳定可靠的运行环境；以Strato入名，寓意为保护openEuler平台上业务平稳运行的轻薄保护层。同时，Strato也承载了项目的愿景与未来：轻量、灵活、 安全和完整的保护能力。

StratoVirt是计算产业中面向云数据中心的企业级虚拟化平台，实现了一套架构统一支持虚拟机、容器、Serverless三种场景，在轻量低噪、软硬协同、安全等方面具备关键技术竞争优势。StratoVirt在架构设计和接口上预留了组件化拼装的能力和接口，StratoVirt可以按需灵活组装高级特性直至演化到支持标准虚拟化，在特性需求、应用场景和轻快灵巧之间找到最佳的平衡点。

代码与团队规模

代码量大约是 27000 行 Rust 代码。

团队规模：

• 主力开发：4 人。

• 社区贡献：15人。

项目周期

2020-09-23，发布 0.1.0 版本。

2021-03-25，发布 0.2.0 版本。

2021-05-28 ，发布 0.3.0 版本。

Firecracker （国外/产品）

关键字：容器/ Serverless/ FaaS

Firecracker[161] 由 AWS 发布并将firecracker开源， 它的定位是面向Serverless计算业务场景。Firecracker本质上是基于KVM的轻量级的microVM， 可以同时支持多租户容器和FaaS场景。Security和Fast是firecracker的首要设计目标。它的设计理念可以概括为：

• 基于KVM

• 精简的设备集（极简主义）

• 基于Rust语言（Builtin Safety）

• 定制的guest kernel（快速启动）

• 优化内存开销（使用musl c）

Firecracker使用了极为精简的设备模型（仅有几个关键的模拟设备），目的是减少攻击面已提升安全性。同时这irecracker使用了一个精简的内核（基于Apline Linux），这使得Firecracker可以做在125ms内拉起一个虚拟机。Firecracker使用musl libc而不是gnu libc，能够将虚拟机的最低内存开销小到5MB。

代码及团队规模

代码量大约为 75000 多行。

团队规模：

• 主力开发：7人

• 社区贡献：140 人

项目周期

从 2018年 3月5号 发布 0.1.0 开始，基本上是每个月发一个小版本。

截止到上个月，刚发布了 0.24.0 版本。

Krustlet （国外/产品）

关键字：Kubernetes/ WebAssembly/ 容器

介绍

微软 Deis Labs[162]发布了Krustlet[163]，它是使用 Rust 实现的一种 Kubernetes kubelet。它监听 Kubernetes API，以获取新的 Pod 请求（在集群中运行基于 WASI 的应用程序），只要请求事件与节点选择器是匹配的。因此，要在 Krustlet 节点上运行应用程序，用户可以使用 taints、tolerations 和节点选择器。此外，用户必须为应用程序生成 WebAssembly 二进制文件。如果应用程序是用 C 语言开发的，就用clang[164]，如果应用程序是用 Rust 开发的，就用cargo[165]。然后，用户必须使用wasm-to-oci[166]打包，并将容器镜像推送到容器注册中心。要部署应用程序，用户需要定义一个 Kubernetes 清单，其中包含 tolerations。

目前该项目还未到 1.0，有很多实验性特性，但是它的存在证明了 WebAssembly 在容器方面的应用方向。但现在 微软加入了 字节码联盟 ，该项目也会连同字节码联盟的其他成员，一起发展 WebAssembly，特别是即将到来的WASI规范工作和模块链接。

代码及团队规模

代码量大约为 21000 多行。

团队规模：

• 主力开发：7人

• 社区贡献：32人

项目周期

自从 2020 年 4月7日，0.1.0 发布以来，大约每一两个月发布一次新版本，目前发布到 0.7.0 版本。

团队有计划在未来几个月内达到 1.0 版本。

linkerd2-proxy （国外/产品）

关键字：服务网格/ k8s

介绍

Linkerd 算是 服务网格的鼻祖，但是由于 Linkerd-proxy 运行需要 Java 虚拟机的支持，在启动时间、预热、内存消耗等方面，相比起晚它半年发布的挑战者 Envoy 均处于全面劣势。后来才重写了 Linkerd2 。

Linkerd2 （曾命名为 Conduit[167]） 是 Buoyant 公司推出的下一代轻量级服务网格框架。与 linkerd 不同的是，它专用于 Kubernetes 集群中，并且比 linkerd 更轻量级（基于 Rust 和 Go，没有了 JVM 等大内存的开销），可以以 sidecar 的方式把代理服务跟实际服务的 Pod 运行在一起（这点跟 Istio 类似）。

linkerd2-proxy [168] 是 Linkerd2 中的底层代理。代理可以说是服务网格中最关键的组件。它可以随应用程序的部署而扩展，因此低附加延迟和低资源消耗至关重要。它也是处理应用程序所有敏感数据的地方，因此安全性至关重要。如果代理速度慢、臃肿或不安全，那么服务网格也是如此。使用 Rust 重写后，Linkerd2-proxy[169]的性能与资源消耗方面都已不输 Envoy。

Rust是Linkerd2-proxy的唯一选择。它提供了闪电般的性能、可预见的低延迟和我们知道服务网格代理需要的安全属性。它还提供了现代语言特性，如模式匹配和富有表现力的静态类型系统，以及工具，如内置的测试框架和包管理器，使在其中编程变得非常愉快。

Linkerd2-proxy 构建在 Rust 异步生态之上，使用了Tokio[170], Hyper[171], and Tower[172] 等框架和库。

代码及团队规模

代码量大约为 43000 多行。

团队规模：

• 主力开发：3 人。

• 社区贡献：37 人。

项目周期

目前该项目已经是 V2.148.0 版本。发布周期大约是每周一个小版本。

Lucet （国外/产品）

关键字：Faas/ Serverless/ WebAssembly / Compiler

Lucet[173] 是一个本机 Webassembly 编译器和运行时。它旨在安全地在您的应用程序内执行不受信任的 WebasseMbly 程序。由 Fastly 公司开发，属于 字节码联盟 的子项目。Fastly 于 2020 年从 Mozilla 招募了 WebAssembly Server side 团队，目前 lucet 团队已经和 wasmtime[174] 团队合并。

Fastly 庞大的 CDN 业务催生了它们进军边缘计算的想法，并逐渐成为其中最具竞争力和投入度最高的头部公司。

关于边缘计算，另外一家头部公司是Cloudflare(NET.US)。从技术角度看，Fastly和Cloudflare在其无服务器边缘计算解决方案中采用了两种不同的方法。

Cloudflare选择在Chromium V8引擎上构建其解决方案。这使得他们可以利用Google(GOOG.US) Chrome团队已经完成的工作，在2018年便将边缘计算产品快速推向市场。

这是对当时由云供应商(如Amazon(AMZN.US) Lambda)提供的无服务器解决方案的重大改进。Cloudflare的工作者将冷启动时间减少了100倍，进入到毫秒阶段。并将内存使用量减少了10倍，从而可以更有效地利用硬件资源。

但Fastly决定不依赖现有技术来进行无服务器计算，例如可重复使用的容器或V8引擎，而是决定全心投入WebAssembly，并构建了自己的Lucet编译器和运行时，对性能、安全性和紧凑性进行了优化。

自2017年以来，Fastly一直在幕后进行这项工作，它为Compute@Edge产品线提供了坚实的基础，该平台现在为多个客户运行生产代码。

Lucet将WebAssembly编译为快速、有效的二进制文件以便执行，还可以通过内存分配来增强安全性，并且不会从先前的请求中产生任何残留。Lucet还包括一个经过严格优化的简化运行时环境，Fastly团队在该环境上花费了大部分开发时间。结果获得了比V8引擎更好的性能。

Fastly冷启动时间完全进入微秒级别--官方宣称为35微秒。这至少比V8引擎快100倍，后者需要3-5毫秒才能启动(3,000到5,000微秒)。

同样，由于Lucet仅包含运行已编译的汇编代码所需的代码模块，因此它只需要几千字节的内存。这大约是V8引擎使用的3MB的千分之一。

代码与团队规模

lucet 代码量为 29000 多行， wasmtime 总代码量为 27万多行。

团队规模：

• 主力开发 ：16 人。

• 社区贡献：200 多人 （wasmtime 贡献者居多）

项目周期

lucet 目前进入维护期，wasmtime在高速重构。

评价迭代周期为 每个月发一个小版本。

wasmcloud （国外/开源/产品）

关键字：WebAssembly/ 分布式计算

介绍

WasmCloud[175] 运行时可以用于云、浏览器和嵌入式等场景。wasmcloud 是一个基于 WebAssembly 的分布式计算平台。比较有创新的地方在于，它制定了一个 waPC 标准，用于 Guest 和 Host 的安全过程调用，来解决当前 WASI 等特性不完善的问题。

代码及团队规模

代码量大约为 11000 多行 Rust 代码。

团队规模：

• 主力开发：2 人。

• 社区贡献：11 人。

项目周期

该项目从 2021 年 2月17 启动，迭代周期大约是每两周一个小版本。

Habitat （国外/开源/运维工具）

关键字：Chef/ DevOps/ 运维工具

介绍

Habitat[176] 让应用团队能够在任何环境中构建、部署、管理任何应用 ，不管是传统的数据中心，还是容器化的微服务。

• “Lift & Shift” 遗留应用到现代平台 。把已有的、对商业至关重要的应用迁移到现代平台上对许多机构来说 是一个痛点。

• 通过云原生（云、容器）的策略来交付 应用 。许多机构在移居和部署云原生平台的 过程中备受阻碍。

特点：

1.  

   Habitat 把管理界面和应用构建在一起，使得自 动化更加简便。

2.  

   Habitat Operator：让你的所有应用仅需一个 Kubernetes Operator，不需 要每个应用都有特制的 Operator。

3.  

   不管你的应用在不在 Kubernetes 上，Habitat 的 Open Service Broker 都能通过 Kubernetes 的原生界面让它们共存。

代码及团队规模

代码量大约为 74000 行 Rust 代码。

团队规模：

• 主力开发：5 人。

• 社区贡献：140人

项目周期

迭代周期为每周一个小版本，目前版本为 1.6.342。

操作系统

操作系统领域包括使用 Rust 实现的各种操作系统。

Rust for Linux （国外/ Rust 进入 Linux 支持项目 ）

关键字：Linux

介绍

Rust for Linux[177] 项目旨在推动 Rust 成为 Linux 内核第二编程语言。

Linux内核是现代互联网的核心，从服务器到客户端设备。它处于处理网络数据和其他形式的输入的第一线。因此，Linux内核中的漏洞会产生广泛的影响，使人们、组织和设备的安全和隐私面临风险。由于它主要是用C语言编写的，而C语言不是内存安全的，所以内存安全漏洞，如缓冲区溢出和使用后赋值，是一个持续的问题。通过使Linux内核的部分内容用Rust语言编写成为可能，这是内存安全的，我们可以完全消除某些组件的内存安全漏洞，比如驱动程序。

当前进展：Google 赞助 且 由 ISRG 组织雇佣 Miguel Ojeda （核心开发），让他全职从事Rust for Linux和其他安全工作，为期一年。希望能通过让他全职从事这项工作，为支持数字基础设施尽一份力。

团队规模

核心开发：1 ～ 6人。

暂未有其他信息。

Coreutils

关键字：GNU/ Shell/ Rust for Linux

介绍

Coreutils[178] 是GNU Shell 的核心实用程序的 Rust 实现。

代码及团队规模

代码量大约为 77000 行 Rust 代码。

团队规模：

• 主力开发：8人

• 社区贡献：250人

项目周期

项目于2020年底启动，迭代周期平均一月一个小版本，目前 0.0.6 版本。目前状态，足以通过 GNOME 启动 Debian 系统。

Occulum （国内/开源/TEE 库操作系统）

关键字：机密计算/ 可信计算/ TEE / 库操作系统

Occulum[179] 是蚂蚁开源的 TEE 操作系统，也是 CCC 机密计算联盟中第一个由中国公司发起的开源项目。

Occlum 提供 POSIX 编程接口，支持多种主流语言（C/C++, Java, Python, Go, Rust 等），支持多种安全文件系统。可以说，Occlum 提供了一个兼容 Linux 的 Enclave 运行环境，使得机密计算可以轻松支持已有的应用，也使得机密应用开发者复用原有开发技能。Occlum 不但在工业界场景中得到了广泛的应用，而且也在系统顶会 ASPLOS 2020 发表了学术论文，代表了机密计算业界的领先水平。

从架构上来看，Occlum 不但提供基本的类似 Linux 的操作系统能力，而且提供一个类似 Docker 的用户使用接口，比如这里的 Occlum build 和 Occlum run 等都跟 docker 的命令类似。

代码与团队规模：

Occulum 代码量大约 28000 多行。

团队规模：

• 主力开发：5人。

• 社区贡献：22 人。

项目周期

迭代周期是每六周发一个新版。

rCore 和 zCore （国内/ 教育/ 学术/ 开源/ 操作系统）

关键字：清华大学/ rCore/ zCore/ 操作系统/ 教学

介绍

rCore[180] 是用 Rust 重新实现的 Linux 内核，诞生于 2018 年，目前已在清华计算机系的操作系统教学实验中试点应用。

zCore[181] 是用 Rust 语言重新实现的 Zircon （Google Fuchsia OS 的微内核）微内核。它运行在内核态，对外提供与 Zircon 完全相同的系统调用，因此能够运行原生的 Fuchsia 用户程序。不仅如此，它还可以作为一个普通的用户进程运行在 Linux 或 macOS 的用户态，我们一般把这种模式称为 LibOS 或 User-Mode OS。你甚至无需安装 QEMU 模拟器，只需装上 Rust 官方工具链，就可以编译运行体验 zCore！

一些相关学习资源：

•  

  下一代 Rust OS：zCore 正式发布[182]

•  

  用`Rust`写操作系统 | 清华 rCore OS 教程介绍[183]

代码及团队规模

rCore 代码量大约为 26000 行 Rust 代码，zCore 代码量大约为 27000 行 Rust 代码。

团队规模：

• 主力开发：3～5人

• 社区贡献：30 人左右

项目周期

两个项目都已进入维护期，没有对外发布版本。

Redox （国外/ 开源/ 操作系统）

关键字：操作系统

介绍

Redox是一个用**Rust**[184]语言编写的类UNIX操作系统 , 它的目标是把Rust语言的创新带入到一个现代的微内核和全系列的应用程序。Redox 幕后公司应该是 System 76 公司。主要项目放在 GitLab 中。

代码及团队开发

代码量目前大约为 134 万行 Rust 代码，算得上是 Rust 生态中重量级项目了。

团队规模：

• 主力开发：21人

• 社区贡献：79 人。

项目周期

Redox 从 2016 年开始立项，直到 2017 年 0.3 版本开始，每年发布一个小版本，到今年已经发布到 0.5 版本。

tockOS （国外/开源/嵌入式实时操作系统）

关键字：嵌入式操作系统/实时

介绍

Tock[185] 是一个嵌入式操作系统，设计用于在基于Cortex-M和RISC-V的嵌入式平台上运行多个并发的、互不信任的应用程序。Tock的设计以保护为中心，既可以防止潜在的恶意应用程序，也可以防止设备驱动程序。Tock使用两种机制来保护操作系统的不同组件。首先，内核和设备驱动程序是用Rust编写的，Rust是一种提供compile-time内存安全、类型安全和严格别名的系统编程语言。Tock使用Rust来保护内核（例如调度程序和硬件抽象层）不受特定于平台的设备驱动程序的影响，并将设备驱动程序彼此隔离。其次，Tock使用内存保护单元将应用程序彼此和内核隔离开来。

Google发布的这个 OpenSK 是跑在 Tock上面的！OpenSK [186]是用Rust编写的安全密钥的开源实现，该密钥同时支持FIDO U2F和FIDO2标准。

代码及团队规模

代码量大约为 15万 行 Rust 代码。

团队规模：

• 主力开发：4 人。

• 社区贡献：123 人。

项目周期

该项目目前已进入维护期。

目前 1.6 版本发布，以往迭代周期大概是每半年发布一个小版本。

Theseus (国外/开源/高端嵌入式操作系统/研究项目)

关键字：嵌入式操作系统/研究型

介绍

Theseus[187] 是美国莱斯大学多年实验的结果，也有其他大学参与，比如耶鲁大学。它通过减少一个组件对另一个组件持有的状态来重新设计和改进操作系统的模块化，并利用一种安全的编程语言 Rust，将尽可能多的操作系统责任转移给编译器。

Theseus 体现了两个主要贡献。

• 一个操作系统结构。其中许多微小的组件具有明确定义的、运行时持久的界限，它们之间的互动不需要彼此持有状态。

• 一种使用语言级机制实现操作系统本身的内部语言方法。这样编译器就可以执行关于操作系统语义的不变性。

Theseus 的结构、内部语言设计和状态管理以超越现有作品的方式实现了核心操作系统组件的实时演进和故障恢复。

更多资料：《Theseus: an Experiment in Operating System Structure and State Management》[188]

代码及团队规模

代码量大约为 56000 行代码。

团队规模：

• 主力开发：1 人。

• 社区贡献：17人。

项目周期

该项目自 2017 年 3月启动，目前已经进入维护期。

工具软件

工具软件包括使用 Rust 实现的一些 命令行工具、桌面软件等。

RustDesk （国内/部分开源/远程桌面软件）

rustdesk[189]，是一款远程桌面软件，开箱即用，无需任何配置，替代TeamViewer和AnyDesk。您完全掌控数据，不用担心安全问题。rustdesk 是一款商业开源软件，开源度 90%。

代码及团队规模

代码量大约为 35000 行 Rust 代码。

团队规模：

• 主力开发：1人。

• 社区贡献：8 人。

项目周期

2021 年 3 月 27 发布 1.1 版本，之前的版本迭代无从知晓。

自此之后基本每月迭代一两个小版本。

spotify-tui （国外/终端音乐软件）