以大见小 - Rust快速实践(一)

目标

被内存安全与极致性能的特性所吸引,前段时间简单了解了一下Rust 语言,然后就更加好奇起来。元旦也出不去就决定进一步学习一下。不想纠结于过多的语言细节,给自己定了一个明确的目标:开发出一个小工具(开源:Ratchet http/https 服务监控)。

这次完成了一些基本功能,对Rust语言有了初步理解,也收集了一些资料,本文做一个整理。然后继续深入学习和迭代完善。

文章难免有错误或疏漏,欢迎指正。如果对内容有意见或建议,或者新的参考资料或信息也希望能留下评论或发给我,我会进一步更新和完善,在这里先谢谢了。

最后,希望能够帮到所有想要初步认识Rust的人。

以大见小 - Rust快速实践(一)- 主观感受
以大见小 - Rust快速实践(二)- 语言部分细节

主观感受

好像同时在接触三种语言;
细节概念较复杂,学习曲线较陡且长;
编译很容易报错,但报错很清晰,便于查询解决问题;
编译较慢,发布程序较小;
三种语言

示例代码

...
    let metrics = vec![
        Gauge::new(grabber.name(), grabber.help()).unwrap(),
    ];

    let descs = metrics
    .iter()
    .map(|c| c.desc().into_iter().cloned())
    .fold(
        Vec::new(),
        |mut acc, ds| {
            acc.extend(ds);
            acc
        },
    );
...

这是项目中的一段代码,写(Copy)这段代码的时候,有一种三种语言混在一起的感觉。感觉信息量也比较多,不用深究,体会一下即可。虽然很容易区分,但是总有几种语言写在一起的感觉。

// 声明与赋值代码!
let metrics = ...
...
let descs = metrics
.iter()
...
... Vec::new()

// vec! 是宏,以叹号'!'结尾,
// 编译时会被展开为代码再进行最终编译!
... = vec![

// |c| ... 和 |mut acc, ds| {} 都是闭包,
// 当闭包中只有一条语句时{} 可以省略;
// 对了,因为没有分号,所以概念上好像应该叫表达式,
// 函数中最后一行没有分号表示这是函数返回值的表达式;
... |c| c.desc().into_iter().cloned()

... |mut acc, ds| {
acc.extend(ds);
acc
}
...

学习曲线

这几天学习下来,感觉上手还算容易,但学习曲线还是比较陡且长的。很多重要的概念要学习要理解,可以慢慢来,也只能慢慢来。比如(按照我的开发使用顺序以及自认为的优先级进行的排序):

  • 包和crate;
  • 表达式和语句;
  • 宏和闭包;
  • 所有权,借用与引用;
  • 泛型、trait 和生命周期;
  • 智能指针;
  • 面向对象,并发,unsafe Rust;
  • 等等......

本文不会也无法涉及如此多的概念,仅做一些简要的介绍。

编译

Rust会在编译时进行大量的静态检查,以尽可能确保运行时安全。也可能是因此编译速度不是很快,并且很容易报错。不过报错基本都很清晰,根据报错的信息线索,基本都能够较快的解决问题。当然,有一些涉及到对语言概念理解的问题则需要多一些时间,不过也更能帮助深入理解Rust这门语言。

error[E0277]: the size for values of type `(dyn Grabber + 'static)` cannot be known at compilation time
  --> common/exporter/src/collector.rs:10:17
   |
10 | pub fn register(grabber: Grabber)
   |                 ^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `Sized` is not implemented for `(dyn Grabber + 'static)`
   = help: unsized locals are gated as an unstable feature
help: function arguments must have a statically known size, borrowed types always have a known size

最终令人比较欣慰的是,程序编译比Java和Golang可运行程序小很多。当然这会由于实现功能的不同而有所不同,但应该只是小多少的问题。

  • Ratchet http/https 服务监控 Rust 实现版本
  • Net_watcher http/https 服务监控 Golang 实现版本
$ ll -lh ./target/release/ratchet
... 13M ... ./target/release/ratchet*
$ ll -lh build/net_watcher 
... 16M ... build/net_watcher*

至于性能,CPU和内存占用问题,以后进一步学习之后再整理一篇文章单独介绍。

初识Rust

内存安全与极致性能

对Rust预研引起兴趣,不仅仅是因为其生态中已经有了丰富的开源项目(GitHub 上有哪些值得关注的 Rust 项目?),甚至已经有使用Rust实现的操作系统!更吸引我的是,很多文章所说的Rust的内存安全与机制性能是否属实?是如何实现的?

我初步了解到有以下几点:

  • 第一:编译时的静态检查:Rust编译时有严格的检查,以增强程序内存使用的安全性;

  • 第二:泛型的单太化:泛型代码在编译时会被展开为静态的特定类型代码;因此如果调用了三个类型的泛型,编译时会被展开为静态的三套类型的特定代码,应该属于空间换时间的一种方法;

  • 第三:Rust运行时没有GC:因此也就完全没有运行时GC进行回收时的任何开销;

运行时比较
Java     分代GC
Golang   三色GC
Rust     无GC

看网上很多的讨论就是关于Rust运行时没有GC的。Java的分代GC与Golang的三色GC虽然一直在尽可能优化,但是仍然需要在一些情况下完全暂停。这可能就是Rust性能高的很重要一点,Rust没有通常理解的独立的GC机制,所以也就不存在暂停的问题。

没有运行时GC并不是完全没有垃圾回收。而是通过语言级概念和语法的严格定义实现了可预定义的回收(Rust有GC,并且速度很快)。Rust要求开发人员对所有权以及生命周期等概念有清晰的理解,并在代码中也要有明确的定义和使用,也就不需要通过运行时GC而直接可以更安全的处理内存(语言级GC?);

  • 通过生命周期管理(释放)栈内存
  • 通过所有权管理(释放)堆内存(释放堆内存,Rust是怎么做的?所有权!)

以大见小,开发稳定并且高性能的程序

在进一步学习具体语法和开发等细节之前,我觉得更应该思考一下学习和实践应该从哪些方面入手。也是偶然一次,因为我曾研究过一段时间Seaweedfs(Golang开发的高并发的分布式文件系统),一个朋友问我Seaweedfs是如何实现高并发的。我讲了很多,却并没有让朋友听明白,因为我当时并没有足够简练的总结出重点。也因此在我重新思考了Seaweedfs的高并发关键因素之后,我有了现在的想法:技术在某种程度上都是相通的,可以以小见大,同样也可以以大见小。对于分布式服务系统的重要因素,同样适用于开发一个独立的服务程序!

Seaweedfs 分布式文件服务稳定和高并发的关键因素

一、可观测:是服务稳定的保证,测试用例,日志输出,监控接口;
二、算法实现:数据结构与索引搜索算法,快速定位数据;
三、资源优化:存储卷,合并小文件,优化IO从而提高整体的吞吐量;
四、分布式:分布式集群,数据副本冗余分发,进一步提高稳定性和并发能力,使服务能够并发访问和故障转移;

稳定高性能的服务程序同样需要关注以下类似的几个因素:

一、可观测:测试用例,日志输出,监控接口;
二、数据结构与算法实现:功能的实现,数据结构和算法的选择;
三、资源优化:语言的资源(比如:锁,内存,引用包提供的数据结构等),调用的资源(比如:依赖包,依赖服务,底层资源,CPU,内存,IO磁盘,网络等等);
四、并发:多线程,协程等
参考项目

为了更快的接触掌握最佳实践,挑选了一个社区活跃的开源项目。参考学习它的项目结构,文件配置以及包的选择。

Lighthouse

项目结构

$ tree
├──lighthouse/                                 // Package
│   ├── Cargo.toml
│   ├── environment                            // Package
│   │   ├── Cargo.toml
│   │   ├── src
│   │   │   └── lib.rs
│   │   └── ...
│   │    ...
│   ├── src
│   │   └── main.rs
│   └──...
├──account_manager/                            // Package
│   ├── Cargo.toml
│   ├── README.md
│   └── src
│       ├── common.rs
│       ├── lib.rs
│       ├── validator
│       │   └── *.rs
│       ...
├──beacon_node/                                // Package
├──book/                                       // Package
├──boot_node/                                  // Package
├──Cargo.toml
...
├──Makefile
├──README.md
...

src/main.rs 是可执行程序crate的根,即可执行程序的构建入口。
src/lib.rs 是库crate的根,即库的构建入口。
一个包中至多只能包含一个库 crate(library crate);
包中可以包含任意多个可执行程序(二进制)crate(binary crate);
包中至少包含一个 crate,无论是库的还是可执行程序的。

实践项目Ratchet 参考了Lighthouse 的项目结构,规划为多个包、箱和模块组成项目,以便功能划分和以后的维护迭代。

./Ratchet
├── Cargo.toml
├── log4rs.yaml                 // 日志配置文件
├── ratchet.yaml                // 服务程序配置文件
├── README.md                   // 项目说明文件
├── Makefile                    // 构建脚本
├── common                      // 通用工具
│   ├── exporter                // 监控接口
│   │   ├── Cargo.toml
│   │   └── src
│   │       ├── collector.rs
│   │       ├── grabber.rs
│   │       └── lib.rs
│   ├── logger                  // 日志
│   │   ├── Cargo.toml
│   │   └── src
│   │       └── lib.rs
│   └── ratchet_version         // 版本信息
│       ├── Cargo.lock
│       ├── Cargo.toml
│       └── src
│           └── lib.rs
├── watcher                     // 检测服务功能实现
│   ├── Cargo.toml
│   └── src
│       ├── config.rs
│       └── lib.rs
└── ratchet                     // 二进制运行程序
    ├── Cargo.lock
    ├── Cargo.toml
    └── src 
       └── main.rs              // 程序入口

先写到这里,本来想写一篇就可以了,结果写了这么多还没到主题。

你可能感兴趣的:(以大见小 - Rust快速实践(一))