75 篇博文 含有标签「Rust」

引言​

在现代编程中，性能优化始终是开发者关注的重点。SIMD（Single Instruction Multiple Data，单指令多数据）作为一种重要的优化手段，能够显著提升单核性能，特别适用于计算密集型任务。

本文将详细介绍如何在稳定版Rust中使用可移植SIMD优化，包括SIMD的基础概念、Rust中的实现方案、实战示例及性能分析，并探讨替代方案和实践建议。

核心概念：

1. SIMD（单指令多数据）优化
2. 可移植SIMD库的使用
3. 稳定版Rust中实现SIMD
4. wide crate的应用

1. SIMD基础概念​

1.1 什么是SIMD​

SIMD允许CPU通过单个指令同时处理多个数据。例如：

• 传统方式：一次只能处理一个数值的加法
• SIMD方式：可以同时进行4个数值的加法运算

这种并行处理能力能够显著提升计算密集型任务的性能，特别是在图像处理、科学计算和数据分析等领域。

1.2 SIMD的挑战​

虽然SIMD强大，但在实际应用中面临以下挑战：

• CPU架构依赖：ARM和x86-64使用不同的SIMD指令集
• 型号限制：即使同为x86-64，不同CPU型号支持的指令集也有差异，例如部分CPU不支持AVX-512 SIMD
• 兼容性问题：需要处理不同平台的适配，确保代码在多种硬件环境下都能高效运行

这些挑战使得编写跨平台的SIMD优化代码变得复杂，需要开发者在不同架构之间进行适配和优化。

2. Rust中的SIMD方案​

2.1 稳定版Rust中主流的SIMD优化方案比较​

在Rust中，有多种方式可以实现SIMD优化，主要包括：

1. std::simd

   • 优点：标准库内置，API一致性好
   • 缺点：仅支持nightly版本Rust，稳定性不足

2. wide crate

   • 优点：支持稳定版Rust，提供跨平台抽象层
   • 特点：基于safe_arch crate，实现了对不同CPU架构的自动适配

3. pulp crate

   • 优点：提供更高级的抽象，文档更完善，适合需要高层次SIMD抽象的项目
   • 缺点：与wide相比，API差异较大，难以进行一对一的函数比较

2.2 wide crate介绍​

use wide::*;

type f64s = f64x4;  // 4通道64位浮点数

主要特性：

• 稳定版Rust支持：无需依赖nightly版本，适用于生产环境
• 自动适配不同CPU架构：基于safe_arch crate，能够在不同架构上生成相应的SIMD指令
• 提供高级抽象接口：简化SIMD编程，提高开发效率

wide与safe_arch的关系： wide crate是基于safe_arch crate实现的。safe_arch提供底层的SIMD指令封装，而wide在此基础上提供更高层次的抽象，使得在稳定版Rust中使用SIMD更加便捷。

3. 实战示例：Mandelbrot算法实现​

3.1 使用wide crate的实现​

use wide::*;

#[derive(Clone)]
struct Complex {
    real: f64s,
    imag: f64s,
}

fn get_count(start: &Complex) -> i64s {
    let mut current = start.clone();
    let mut count = f64s::splat(0.0);
    let threshold_mask = f64s::splat(THRESHOLD);

    for _ in 0..ITER_LIMIT {
        let rr = current.real * current.real;
        let ii = current.imag * current.imag;

        let undiverged_mask = (rr + ii).cmp_le(threshold_mask);
        if !undiverged_mask.any() {
            break;
        }

        count += undiverged_mask.blend(
            f64s::splat(1.0),
            f64s::splat(0.0)
        );

        let ri = current.real * current.imag;
        current.real = start.real + (rr - ii);
        current.imag = start.imag + (ri + ri);
    }
    count.round_int()
}

代码详解：

• 结构体定义：Complex结构体包含实部和虚部，均为f64s类型（4通道64位浮点数）。
• 函数get_count：
  • 初始化：克隆起始复数，初始化计数器和阈值掩码。
  • 迭代计算：在每次迭代中计算当前复数的平方，并判断是否超出阈值。
  • 掩码操作：使用cmp_le进行比较，生成掩码；使用blend根据掩码选择性地增加计数。
  • 更新复数：根据Mandelbrot算法更新实部和虚部。
  • 结果转换：将浮点计数结果转换为整数。

3.2 性能对比​

不同实现方式的性能数据：

性能分析：

• std::simd在单核运行时间上明显优于wide，这可能由于std::simd更贴近底层硬件指令，优化程度更高。
• 在多核运行时间上，wide的表现略逊于std::simd，但仍远优于标量实现。
• wide的性能稍慢可能源于其高层抽象带来的额外开销，或是某些操作未能完全优化为底层指令。

4. 实践建议​

4.1 编译优化​

需要启用SIMD CPU特性，以确保编译器生成相应的SIMD指令：

RUSTFLAGS="-C target-cpu=native" cargo build --release

说明：

• -C target-cpu=native使编译器针对本地CPU进行优化，启用所有可用的SIMD指令集。

4.2 使用注意事项​

1. API文档：

   • wide crate的文档相对有限，部分API缺乏详细说明。
   • 可以参考safe_arch crate的文档，wide基于safe_arch，通过了解safe_arch的API，可以更好地理解和使用wide的功能。
   • 部分API需要通过实践理解，例如blend和cmp_le等函数。

2. 替代方案：

   • pulp crate：
     • 特点：另一个稳定版可用的SIMD抽象库，提供更高级的抽象，自动进行批处理和运行时调度。
     • 优点：文档更完善，易于上手，适合需要更高层次抽象的项目。
     • 缺点：与wide相比，API差异较大，难以进行一对一的函数比较。
   • 选择建议：根据项目需求选择合适的SIMD库。如果需要更高的抽象和更完善的文档，可以考虑使用pulp；如果需要更接近底层的控制，可以选择wide。

5. 总结与展望​

SIMD优化为性能提升提供了重要途径：

1. 与多线程并行优化结合：SIMD与多线程可以协同工作，进一步提升性能。
2. wide crate的作用：wide crate使得在稳定版Rust中也能方便地使用SIMD，降低了使用门槛。
3. 不同实现方案的优势：
   • std::simd提供更高的性能但需要nightly Rust
   • wide在稳定版Rust中提供便捷的SIMD使用
   • pulp则提供更高层次的抽象和更好的文档支持

建议：

• 考虑SIMD优化：在需要性能优化的场景下，考虑使用SIMD以提升计算效率。
• 选择合适的SIMD库：根据项目需求和开发者熟悉程度，选择合适的SIMD库，如wide或pulp。
• 注意跨平台兼容性：确保所选SIMD库在目标平台上有良好的支持，避免架构依赖带来的兼容性问题。

未来展望：

• 更多优化：深入分析和优化wide crate的性能，探索如何减少高层抽象带来的开销。
• 完善文档：期待wide和相关库的文档逐步完善，降低学习曲线。
• 社区支持：随着Rust生态的发展，更多可移植SIMD库将涌现，提供多样化的选择。

参考资源​

• wide crate文档
• safe_arch crate文档
• pulp crate文档
• Rust官方SIMD文档
• std::simd GitHub仓库

目录​

1. 什么是Builder模式？
2. Typestate模式的应用
3. Bon库核心特性与代码示例
4. Bon与其他Builder库的对比分析
5. 性能优化策略
6. Rust Builder模式的实际应用案例
7. 高级使用技巧与最佳实践建议
8. 总结与参考链接

1. 什么是Builder模式？​

1.1 Builder模式概述​

Builder模式是一种创建型设计模式，主要用于构建复杂对象。它通过逐步设置对象的属性来创建对象，而不是在一个庞大的构造函数中传入所有参数，从而提升了代码的可读性与维护性。

1.2 为什么选择Builder模式？​

在开发过程中，如果遇到以下场景，Builder模式可以极大地提升代码的可读性和可维护性：

• 构造函数参数过多：Builder模式允许开发者逐步构建对象，通过链式调用来设置属性，这样可以避免大量参数传递所带来的困扰。
• 处理可选参数：Builder模式提供了一种优雅的方式处理可选参数，避免多层的Option嵌套。

// 不使用Builder模式 - 难以阅读和维护
let user = User::new("John", "Doe", 25, "john@example.com", "123 Street", true, false);

// 使用Builder模式 - 清晰直观
let user = User::builder()
    .name("John")
    .email("john@example.com")
    .age(25)
    .address("123 Street")
    .build();

1.3 Builder模式的主要优势​

1. 提高代码可读性：每个属性都可以被清楚地命名和设置。
2. 类型安全：通过编译时类型检查，保证所有必要的参数都已经设置，避免运行时错误。
3. 易于扩展和维护：可以轻松添加新的属性而不影响现有代码。

2. Typestate模式的应用​

2.1 Typestate模式的概念​

Typestate模式利用Rust强大的类型系统来确保对象在正确的状态下被使用。它能有效防止对象在无效状态下执行操作，从而减少运行时的错误风险。

2.2 Typestate模式的示例代码​

以下代码展示了如何使用Typestate模式在构建对象时确保参数完整性：

use std::marker::PhantomData;

struct Uninitialized;
struct HasName;
struct HasEmail;

// Builder实现
struct UserBuilder<State> {
    name: String,
    email: String,
    _state: PhantomData<State>
}

impl UserBuilder<Uninitialized> {
    fn new() -> Self {
        UserBuilder {
            name: String::new(),
            email: String::new(),
            _state: PhantomData
        }
    }

    fn name(self, name: String) -> UserBuilder<HasName> {
        UserBuilder {
            name,
            email: self.email,
            _state: PhantomData
        }
    }
}

通过上述实现，开发者可以确保在编译阶段就完成对对象状态的检查。

3. Bon库核心特性与代码示例​

3.1 Bon库的基础使用​

Bon库为Rust提供了强大的Builder模式实现，可以轻松地构建复杂对象。

use bon::Builder;

#[derive(Builder)]
struct User {
    name: String,
    #[builder(default)]
    age: Option<u32>,
    email: String,
}

3.2 Bon库的高级特性​

1. 自定义验证规则
   • 可以通过#[builder(validate)]属性为字段添加自定义验证逻辑。
   #[derive(Builder)]
   struct Server {
       #[builder(validate = port > 1000)]
       port: u16,
       #[builder(validate = |host: &str| host.contains("."))]
       host: String,
   }
   
2. 默认值设置
   • 使用#[builder(default)]或直接指定默认值来简化对象构建。
   #[derive(Builder)]
   struct Config {
       #[builder(default = 8080)]
       port: u16,
       #[builder(default = String::from("localhost"))]
       host: String,
   }
   
3. 类型转换
   • Bon支持自动类型转换，例如into和try_into，使得构建器更加灵活。
   #[derive(Builder)]
   struct Connection {
       #[builder(into)]
       address: String,
       #[builder(try_into)]
       timeout: Duration,
   }
   

4. Bon与其他Builder库的对比分析​

4.1 Bon库 vs typed-builder​

// typed-builder
#[derive(TypedBuilder)]
struct User {
    name: String,
    email: Option<String>,
}

// Bon
#[derive(bon::Builder)]
struct User {
    name: String,
    email: Option<String>,
}

主要区别​

1. 类型状态表示
   • Bon使用更简洁的嵌套类型，而typed-builder依赖更为复杂的元组类型。
2. 编译性能
   • Bon生成更少的代码，因此具有更快的编译速度。

4.2 性能优化策略​

1. 零成本抽象
   #[derive(bon::Builder)]
   struct OptimizedConfig {
       #[builder(inline)]
       name: String,
       #[builder(no_clone)]
       data: Vec<u8>,
   }
   
2. 内存优化
   • Bon支持#[builder(no_std)]，帮助开发者在内存受限的环境中构建对象。
   #[derive(bon::Builder)]
   #[builder(no_std)]
   struct MinimalStruct {
       value: u32,
   }
   

5. Rust Builder模式的实际应用案例​

5.1 数据库配置构建器​

#[derive(bon::Builder)]
struct DatabaseConfig {
    host: String,
    port: u16,
    #[builder(default = 30)]
    timeout_seconds: u32,
    #[builder(default)]
    max_connections: Option<u32>,
}

// 使用示例
let config = DatabaseConfig::builder()
    .host("localhost".to_string())
    .port(5432)
    .timeout_seconds(60)
    .build()?;

5.2 HTTP客户端构建器​

#[derive(bon::Builder)]
struct HttpClient {
    #[builder(default = "https://api.example.com")]
    base_url: String,
    #[builder(default = Duration::from_secs(30))]
    timeout: Duration,
    #[builder(default)]
    headers: HashMap<String, String>,
}

// 使用示例
let client = HttpClient::builder()
    .base_url("https://api.custom.com".to_string())
    .timeout(Duration::from_secs(60))
    .build()?;

6. 高级使用技巧与最佳实践建议​

6.1 设计原则​

1. 保持简单性：仅为必要的字段添加构建器，以避免代码复杂化。
2. 类型安全：通过Rust类型系统保证对象构建的正确性。
3. 文档完备：为每个字段添加注释，提供使用示例以提高代码的易用性。

6.2 示例代码​

/// 应用配置构建器
#[derive(bon::Builder)]
#[builder(doc = "构建应用配置")]
struct AppConfig {
    /// 服务器监听端口
    #[builder(default = 8080)]
    port: u16,
    
    /// 数据库连接URL
    #[builder(validate = |url: &str| url.starts_with("postgres://"))]
    database_url: String,
    
    /// 日志级别
    #[builder(default = "info")]
    log_level: String,
}

7. 总结与参考链接​

Bon库提供了Rust开发中非常强大且灵活的Builder模式实现，其优势在于：

• 简化开发：自动生成构建器代码，减少样板代码。
• 保证安全：通过编译时类型检查和自定义验证，保证对象的正确性。
• 优化性能：提供零成本抽象，最小化运行时开销。

通过合理使用Bon库，我们可以编写出更加健壮、可维护的Rust代码。

参考链接​

• Next-gen builder macro Bon 3.0 released

新发布的声明概述了改进语言互操作性的战略愿景，并呼吁社区参与，共同提升Rust与C++的兼容性。

2024年11月12日，Rust基金会团队发布了一份关于C++和Rust互操作性的重要声明。

概要​

Rust基金会（一个独立的非营利组织，致力于推动Rust编程语言的发展）发布了这份声明，全面阐述了Rust与C++在互操作性方面的挑战和机遇。这份声明对开发者意义重大，标志着跨语言开发向着更高效、更安全、更易访问的方向迈出了重要一步。

互操作性的意义​

Rust与C++都是系统编程领域的重要编程语言，但在跨语言开发时，互操作性问题一直是开发者的难点。Rust基金会发布的这份声明，旨在推动这两种语言之间的无缝集成，使得Rust和C++的开发者能够更方便地利用各自的优势，共同构建高性能和高安全性的系统。

三大战略方向​

Rust基金会在声明中概述了三个关键战略方向，旨在逐步解决C++与Rust互操作性问题：

1. 短期改进​

• 改进现有工具：通过对现有的Rust和C++工具链进行改进，减少互操作过程中的摩擦和风险。
• 解决战术性问题：重点处理Rust项目中存在的一些互操作性痛点，提供快速的战术性改进。
• 减少摩擦：特别关注开发者在C++与Rust互操作过程中遇到的兼容性和工具问题。

2. 长期目标共识​

• 达成共识：在需要对Rust语言本身进行的长期改动方面达成一致。
• 推进长期目标：制定开始推进这些长期目标的战术方法，确保互操作性的根本性改进。

3. 社区合作​

• 跨社区协作：与C++社区及相关标准化委员会紧密合作，促进Rust与C++之间的高质量互操作。
• 安全性与性能提升：通过合作提高两种语言的安全性和性能，实现双方的共同目标。

互操作性计划详情​

背景介绍​

Rust基金会在2024年2月启动了这项"互操作性计划"，得到了Google公司提供的100万美元捐助。该计划的启动标志着Rust和C++将在系统编程的未来发挥关键作用。虽然Rust一直以来主要关注与C语言的兼容性，但开发成熟的标准化C++/Rust互操作方法对于未来的发展至关重要。

项目领导​

• Jon Bauman：于2024年6月加入Rust基金会，担任Rust-C++互操作性工程师，领导项目的执行。
• 协作式方法：Jon Bauman倡导采用协作式的问题空间方法，邀请两个语言社区的关键利益相关者参与。
• 问题声明：发布的问题声明并不是对具体解决方案的规定，而是提供一个合作基础，推动各方就问题达成共识。

如何参与Rust和C++互操作性计划​

Rust基金会鼓励社区对这份声明提供反馈，并欢迎开发者积极参与互操作性计划。以下是您可以参与的几种方式：

1. 加入讨论：通过t-lang/interop Zulip频道，与其他开发者就互操作性问题进行交流。
2. 发送建议：如果您有任何关于互操作性的建议，可以发送邮件至interop@rustfoundation.org。
3. 关注Rust基金会博客：通过博客获取最新的计划更新和相关资讯。
4. 查看完整声明：访问Rust基金会的官方网站，查看并评论完整的问题声明，表达您的意见和建议。

进展的更新将通过这些渠道共享，并向包括Rust项目维护者在内的Rust基金会董事会汇报。

关于Rust基金会​

Rust基金会是一个独立的非营利组织，致力于管理和推进Rust编程语言的发展。其主要目标包括：

• 管理语言的演进：监督Rust语言的长期演进和治理。
• 培育Rust生态系统：通过资助和支持关键项目来促进Rust生态的健康发展。
• 支持开发者：为开发和维护Rust语言及相关工具的开发者团队提供支持。

通过这些努力，Rust基金会确保Rust语言在全球范围内保持高质量、高性能的发展方向。

了解更多关于Rust基金会的信息，请访问官网: rustfoundation.org

原文链接​

• 查看Rust基金会发布的C++/Rust互操作性声明

1. 引言​

Rust语言提供了迭代器，使得复杂的数据结构遍历、转换和过滤变得简单。

Rust中常见的迭代器包括iter()、iter_mut()和into_iter()。iter()和into_iter()针对不同的使用场景提供了便利。

在本教程中，我们将学习iter()和into_iter()的基础知识，最后通过一个示例用例，了解何时使用哪种迭代器。

2. 理解迭代器​

迭代器是允许我们遍历一系列元素的对象。它通过next()方法一个一个地返回元素。

迭代器是惰性的，即它们在被for循环、collect等操作消费之前不会执行。

常见的迭代器包括：​

• iter()：允许我们遍历元素的不可变引用。
• iter_mut()：允许我们遍历元素的可变引用，能够对元素进行修改。
• into_iter()：允许我们遍历元素的所有权序列，即迭代器会接管元素的所有权。

3. iter()​

让我们深入了解iter()迭代器。它允许我们在不可变引用上创建迭代器：

let names = vec!["Java", "Rust", "Python"];
let mut len = 0;
for name in names.iter() {
    len += name.len();
}
assert_eq!(14, len);

在上述代码中，我们初始化了一个名为names的变量，它是一个包含三个元素的向量。

接下来，我们使用iter()方法遍历向量中的每个元素。通过调用iter()函数，我们可以依次处理向量中的每个元素。

最后，我们遍历迭代器并将所有元素的长度相加。

进一步说明​

• 所有权保持：iter()不会取得原始集合的所有权，因此我们仍然可以在循环后使用names变量。

println!("{:?}", names);

这里，我们仍然可以使用names变量，因为iter()不会获取集合的所有权。

• 不可变引用：iter()无法在迭代过程中修改向量中的元素。

for name in names.iter() {
		*name = "C++"; // 这会报错，因为`iter()`返回的是不可变引用
		len += name.len();
}

上述代码会报错，因为我们试图修改一个不可变引用。 即使names变量是可变的，iter()仍然无法修改向量的内容。在这种情况下，我们可以使用iter_mut()函数。

4. into_iter()​

into_iter()迭代器的工作方式类似于iter()，但它会取得变量的所有权：

let names = vec!["Java", "Rust", "Python"];
let mut len = 0;
for name in names.into_iter() {
    len += name.len();
}
assert_eq!(14, len);

上述代码与之前的iter()示例类似，但我们使用了into_iter()。这个函数会取得names变量的所有权。

所有权转移​

println!("{:?}", names); // 这会报错，因为`into_iter()`已经取得了`names`的所有权

上述代码会报错，因为into_iter()取得了names的所有权，导致我们无法再次使用它。

可变引用​

通过into_iter()，我们可以在迭代过程中修改集合的内容：

for mut name in names.into_iter() {
    name = "C++"; // 这是允许的，因为我们已经取得了所有权
    len += name.len();
}

在这个例子中，我们修改了元素的值，因为into_iter()已经取得了所有权。

5. 关键区别​

两者都可以应用于数据集合，但有以下不同：

• 所有权：

  • iter(): 不会取得集合的所有权，允许在迭代后继续使用集合。
  • into_iter(): 会取得集合的所有权，迭代后集合不再可用。

• 可变性：

  • iter(): 返回不可变引用，无法修改集合中的元素。
  • iter_mut(): 返回可变引用，允许修改集合中的元素。
  • into_iter(): 取得所有权，可以对元素进行完全的所有权操作，包括修改。

使用场景​

• 只需要读取元素：使用iter()。
• 需要修改元素：使用iter_mut()。
• 需要取得元素的所有权：使用into_iter()。

6. 结论​

在本教程中，我们学习了Rust中iter()和into_iter()函数的基础知识，并通过示例了解了它们之间的区别和使用场景。

简而言之：

• 使用iter()当你需要只读访问集合中的元素且不需要取得所有权时。
• 使用iter_mut()当你需要在遍历过程中修改集合中的元素时。
• 使用into_iter()当你需要取得集合中元素的所有权，并且不再需要使用原始集合时。

通过选择合适的迭代器，你可以编写更高效、更安全的Rust代码，充分利用Rust的所有权和借用机制。

Rust作为一门现代系统编程语言，以其安全性、高性能和强大的并发能力迅速赢得了开发者的青睐。

然而，掌握Rust的基础语法和编写简单项目只是开始，真正深入Rust的世界， 还需要理解其生态系统、并发编程模式、高级错误处理机制以及资源管理等高级特性。

本文将基于Thorsten Ball的文章《Rust Prism》，详细探讨什么是真正世界的Rust编程，并通过具体示例说明其核心概念。

目录​

1. 引言
2. 基础Rust编程 vs. 真实世界的Rust编程
3. 使用第三方库与生态系统
4. 并发与异步编程
5. 高级错误处理
6. 资源管理与生命周期
7. 复杂代码结构与设计模式
8. 实际项目中的Rust应用案例
9. 结论

引言​

Rust以其内存安全和并发性能著称，适用于系统级编程、嵌入式开发、Web服务等多个领域。

随着Rust生态系统的不断扩展，开发者们在实际项目中接触到了更多高级特性和第三方库，从而提升了编程效率和代码质量。 然而，这也意味着仅掌握基础知识已不足以应对复杂的实际需求。

本文将通过分析实际项目中的Rust代码，揭示真正世界的Rust编程所涉及的关键要素。

基础Rust编程 vs. 真实世界的Rust编程​

在学习Rust的初期，开发者通常会通过编写简单的控制台程序、实现基本的数据结构或算法来熟悉语言的语法和特性。 然而，随着项目规模的扩大，需求的复杂化，单纯依靠基础知识已经难以胜任。

这时，真实世界的Rust编程便应运而生，它涵盖了对第三方库的依赖、并发处理、错误管理以及资源生命周期的精细控制等高级内容。

示例对比​

• 基础Rust示例：

fn main() {
    let message = greet("World");
    println!("{}", message);
}

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

• 真实世界Rust示例：

use reqwest::Error;
use tokio::time::{sleep, Duration};
use anyhow::Result;

async fn send_request(url: &str, metrics: &mut Metrics) -> Result<String> {
    let mut finish = defer(|| metrics.requests += 1);

    let request = reqwest::get(url);
    tokio::select! {
        response = request => {
            let response = response?;
            let body = response.text().await?;
            Ok(body)
        }
        _ = sleep(Duration::from_millis(2500)) => {
            finish.abort();
            Err(anyhow::anyhow!("timeout"))
        }
    }
}

通过对比，可以看到真实世界的Rust代码涉及异步编程、第三方库的使用以及复杂的错误处理机制， 这些都是基础Rust编程中较少涉及的内容。

使用第三方库与生态系统​

Rust拥有丰富的第三方库（crates），覆盖了从网络编程、数据库交互到并发处理等各个方面。

充分利用这些库不仅能提升开发效率，还能借助社区的力量解决常见问题。

关键库介绍​

1. Tokio：一个用于编写异步应用的运行时，提供了丰富的工具来处理异步I/O操作。
2. Reqwest：一个高层次的HTTP客户端库，简化了HTTP请求的发送与响应处理。
3. Anyhow：一个用于错误处理的库，提供了便捷的错误类型封装，适用于应用层的错误管理。

示例：使用Reqwest和Tokio进行异步HTTP请求​

use reqwest::Error;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let url = "https://api.example.com/data";
    let response = send_request(url).await?;
    println!("Response: {}", response);
    Ok(())
}

async fn send_request(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

在这个示例中，reqwest库用于发送HTTP GET请求，而tokio提供了异步运行时，使得请求能够非阻塞地进行。

并发与异步编程​

并发和异步编程是现代应用程序中提升性能和响应能力的重要手段。

Rust通过其所有权系统和类型检查机制，提供了安全且高效的并发编程模式。

Tokio的select宏​

tokio::select!宏允许同时等待多个异步操作，一旦其中一个完成，其他操作将被取消。

这在处理超时、并发请求等场景中尤为重要。

示例：并发处理HTTP请求与超时​

use reqwest::Error;
use tokio::time::{sleep, Duration};
use anyhow::Result;

async fn send_request(url: &str, metrics: &mut Metrics) -> Result<String> {
    let mut finish = defer(|| metrics.requests += 1);

    let request = reqwest::get(url);
    tokio::select! {
        response = request => {
            let response = response?;
            let body = response.text().await?;
            Ok(body)
        }
        _ = sleep(Duration::from_millis(2500)) => {
            finish.abort();
            Err(anyhow::anyhow!("timeout"))
        }
    }
}

在这个示例中，tokio::select!同时等待HTTP请求的响应和一个超时操作。 如果请求在2500毫秒内完成，则返回响应内容；否则，取消请求并返回超时错误。

高级错误处理​

在复杂的应用程序中，错误处理需要更加灵活和健壮。

Rust的错误处理机制通过Result类型和各种错误处理库，如anyhow和thiserror，提供了强大的支持。

Anyhow的优势​

anyhow库提供了一个通用的错误类型，允许开发者将不同类型的错误统一处理，简化了错误传播和转换的过程。

示例：使用Anyhow进行错误处理​

use anyhow::{Result, anyhow};
use reqwest::Error;
use tokio::time::{sleep, Duration};

async fn send_request(url: &str) -> Result<String> {
    let response = reqwest::get(url).await?;
    if response.status().is_success() {
        let body = response.text().await?;
        Ok(body)
    } else {
        Err(anyhow!("Request failed with status: {}", response.status()))
    }
}

在此示例中，anyhow::Result用于统一错误类型，简化了错误处理逻辑，使代码更加简洁易读。

资源管理与生命周期​

Rust通过所有权系统和生命周期标注，确保了内存和资源的安全管理。

然而，在复杂项目中，开发者可能需要更精细地控制资源的生命周期，这时Drop特性和自定义资源管理机制就显得尤为重要。

使用Drop特性进行资源管理​

Drop特性允许开发者在值被销毁时执行自定义代码，常用于释放资源或执行清理操作。

示例：自定义资源管理与Defer模式​

struct Deferred<T: FnOnce()> {
    task: Option<T>,
}

impl<T: FnOnce()> Deferred<T> {
    fn abort(&mut self) {
        self.task.take();
    }
}

impl<T: FnOnce()> Drop for Deferred<T> {
    fn drop(&mut self) {
        if let Some(task) = self.task.take() {
            task();
        }
    }
}

fn defer<T: FnOnce()>(f: T) -> Deferred<T> {
    Deferred { task: Some(f) }
}

struct Metrics {
    requests: usize,
}

async fn send_request(url: &str, metrics: &mut Metrics) -> Result<String> {
    let mut finish = defer(|| metrics.requests += 1);

    let request = reqwest::get(url);
    tokio::select! {
        response = request => {
            let response = response?;
            let body = response.text().await?;
            Ok(body)
        }
        _ = sleep(Duration::from_millis(2500)) => {
            finish.abort();
            Err(anyhow::anyhow!("timeout"))
        }
    }
}

在这个示例中，Deferred结构体与Drop特性结合，实现了在函数结束时自动增加请求计数， 除非调用了abort方法取消该操作。

这种模式类似于其他语言中的defer关键字，提供了一种优雅的资源管理方式。

复杂代码结构与设计模式​

真实世界的Rust项目往往涉及复杂的代码结构和多种设计模式。

良好的代码组织和设计不仅提升了代码的可维护性，也增强了系统的扩展性。

示例：编写一个编译器​

编写编译器是一个复杂且挑战性的项目，涉及词法分析、语法分析、语义分析、代码生成等多个阶段。

Rust凭借其性能和安全性，成为编写编译器的理想选择。

struct Compiler {
    tokens: Vec<Token>,
    // 其他编译器状态
}

impl Compiler {
    fn new() -> Self {
        Compiler {
            tokens: Vec::new(),
            // 初始化其他状态
        }
    }

    fn tokenize(&mut self, source: &str) {
        // 实现词法分析
    }

    fn parse(&mut self) {
        // 实现语法分析
    }

    fn generate_code(&self) -> String {
        // 实现代码生成
        String::new()
    }

    fn compile(&mut self, source: &str) -> String {
        self.tokenize(source);
        self.parse();
        self.generate_code()
    }
}

fn main() {
    let mut compiler = Compiler::new();
    let source_code = "fn main() { println!(\"Hello, Rust!\"); }";
    let compiled_code = compiler.compile(source_code);
    println!("Compiled Code:\n{}", compiled_code);
}

在这个简化的示例中，编译器结构体Compiler包含了词法分析、语法分析和代码生成等方法。

实际项目中，编译器的代码量和复杂度远超此示例，但它展示了Rust在处理复杂项目时的组织能力。

实际项目中的Rust应用案例​

通过参与实际项目，开发者可以深入理解Rust的强大功能和灵活应用。

以下是几个真实世界中的Rust应用案例：

1. Web服务器​

Rust的高性能和并发能力使其成为开发高效Web服务器的理想选择。

例如，使用actix-web框架，可以轻松构建高并发的Web应用。

use actix_web::{web, App, HttpServer, Responder};

async fn greet() -> impl Responder {
    "Hello, World!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

2. 命令行工具​

Rust的二进制文件小且执行高效，适合开发命令行工具。

使用clap库，可以快速解析命令行参数。

use clap::{App, Arg};

fn main() {
    let matches = App::new("My CLI")
        .version("1.0")
        .author("Author Name <author@example.com>")
        .about("Does awesome things")
        .arg(Arg::with_name("config")
            .short('c')
            .long("config")
            .value_name("FILE")
            .help("Sets a custom config file")
            .takes_value(true))
        .get_matches();

    if let Some(config) = matches.value_of("config") {
        println!("Using config file: {}", config);
    } else {
        println!("No config file specified.");
    }
}

3. 系统级工具​

Rust的内存安全特性使其适用于开发系统级工具，如操作系统内核、驱动程序等。

著名的Redox OS就是用Rust编写的操作系统项目。

结论​

真正世界的Rust编程远不仅仅是掌握基础语法和编写简单程序。

它涉及广泛的生态系统、并发与异步编程、高级错误处理、资源管理以及复杂的代码结构和设计模式。

通过参与实际项目，开发者不仅能够全面理解Rust的强大功能，还能在高性能和系统编程领域中充分发挥Rust的优势。

Rust的学习之路虽然充满挑战，但其带来的安全性和效率提升，无疑为开发者提供了强大的动力和信心。

参考文献​

• Rust官方文档
• Tokio异步运行时
• Reqwest HTTP客户端
• Anyhow错误处理库
• Actix Web框架
• Clap命令行解析库
• Rust Prism

致谢​

感谢Thorsten Ball的文章《Rust Prism》，为本文提供了宝贵的思路和示例代码。 通过对其内容的深入分析和扩展，希望能为Rust开发者提供更清晰的理解和实用的指导。

结束语​

希望这篇详细的博客能够帮助你更好地理解真正世界的Rust编程，并在实际项目中应用这些知识，提升开发效率和代码质量。

Rust生态系统中一个纯Rust实现的Actor框架——Ractor。构建于Tokio之上。

它受Erlang的gen_server启发，同时具备Rust的速度和性能优势！

引言​

在软件开发中，时间是有限的资源。你和我只有一小段时间来编写软件。而在同样的时间块内，有些人能够构建出令人惊叹的软件，而另一些人则困在项目的边缘，进行一些他们从未真正理解的小改动。你可能会认为这是随机的，或者试图找出为什么有些人能极大地提高生产力，而另一些人却在同样的问题上反复挣扎。

在你对我竖起叉子之前，我并不是在谈论那些在财务上取得成功或拥有大量用户的软件。我们都知道，与其他产品相比，Microsoft Teams的质量并不出众，但它拥有数量级更多的用户。商业策略如捆绑销售可能使产品质量变得无关紧要，只要你关注的是用户数量。我所说的是构建优秀的软件；我希望开发出其他像我一样喜欢的软件。你不也是这样吗？

一些需要记住的符号​

在深入本教程之前，有几个符号需要澄清，以便读者能够更好地理解内容。

消息传递的Actors​

由于我们试图尽可能地模仿Erlang的实践，Ractor中的消息发送可以通过两种方式进行：

1. First-and-Forget（发送后不等待回复）：对应Erlang中的cast。
2. 等待回复（等待消息处理后的回复）：对应Erlang中的call。

这种命名方式遵循了Erlang的命名约定，使得开发者在使用Ractor时能够更容易理解和上手。

安装Ractor​

要在你的Rust项目中使用Ractor，只需在Cargo.toml文件的依赖部分添加以下内容：

[dependencies]
ractor = "0.9"

然后运行cargo build以安装Ractor。

第一个Actor​

当然，我们需要从标志性的“Hello World”示例开始。我们希望构建一个Actor，每收到一条消息就打印“Hello World”。首先，我们定义消息类型，然后定义Actor本身。

定义消息类型​

pub enum MyFirstActorMessage {
    /// 打印“Hello World”
    PrintHelloWorld,
}

定义Actor​

use ractor::{Actor, ActorRef, ActorProcessingErr};

pub struct MyFirstActor;

#[async_trait::async_trait]
impl Actor for MyFirstActor {
    type State = ();
    type Msg = MyFirstActorMessage;
    type Arguments = ();

    async fn pre_start(&self, _myself: ActorRef<Self::Msg>, _arguments: Self::Arguments)
        -> Result<Self::State, ActorProcessingErr> 
    {
        Ok(())
    }
}

解析​

1. 结构体定义：首先定义一个空的结构体MyFirstActor，它将作为我们的Actor。

2. 实现Actor trait：通过#[async_trait::async_trait]宏实现Actor trait，定义以下关联类型：

   • State：Actor的状态，这里是空的()，表示无状态。
   • Msg：Actor处理的消息类型，即我们定义的MyFirstActorMessage。
   • Arguments：Actor启动时的参数，这里也是空的()。

3. pre_start方法：定义Actor启动时的初始化逻辑，这里我们返回一个空的状态Ok(())。

添加消息处理​

现在，如何让Actor在接收到消息时打印“Hello World”呢？我们需要实现消息处理逻辑。

#[async_trait::async_trait]
impl Actor for MyFirstActor {
    type State = ();
    type Msg = MyFirstActorMessage;
    type Arguments = ();

    async fn pre_start(&self, _myself: ActorRef<Self::Msg>, _arguments: Self::Arguments)
        -> Result<Self::State, ActorProcessingErr>
    {
        Ok(())
    }

    async fn handle(&self, _myself: ActorRef<Self::Msg>, message: Self::Msg, _state: &mut Self::State) 
        -> Result<(), ActorProcessingErr>
    {
        match message {
            MyFirstActorMessage::PrintHelloWorld => {
                println!("Hello World!");
            }
        }
        Ok(())
    }
}

解析​

• handle方法：实现handle方法，用于处理每一条接收到的消息。
  • 当收到PrintHelloWorld消息时，打印“Hello World!”。

运行第一个Actor​

将所有部分组合在一起，创建一个完整的程序。

#[tokio::main]
async fn main() {
    // 启动Actor，并获取其引用和JoinHandle
    let (actor, actor_handle) = Actor::spawn(None, MyFirstActor, ()).await.expect("Actor failed to start");
    
    for _ in 0..10 {
        // 发送消息，不等待回复
        actor.cast(MyFirstActorMessage::PrintHelloWorld).expect("Failed to send message to actor");
    }

    // 等待一段时间，让所有消息都有机会被处理
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;

    // 清理资源，停止Actor
    actor.stop(None);
    actor_handle.await.unwrap();
}

解析​

1. 启动Actor：使用Actor::spawn方法启动MyFirstActor，并获取其引用actor和JoinHandle``actor_handle。
2. 发送消息：通过actor.cast方法发送10条PrintHelloWorld消息，Actor会依次处理并打印“Hello World!”。
3. 等待处理：使用tokio::time::sleep等待100毫秒，确保所有消息都有机会被处理。
4. 停止Actor：调用actor.stop(None)停止Actor，并等待actor_handle完成。

添加状态​

现在，如果我们希望Actor能够维护一些状态，例如记录它已经打印了多少次“Hello World”，该如何做呢？让我们来看一个具体的例子。

修改消息类型​

use ractor::{Actor, ActorRef, ActorProcessingErr, RpcReplyPort};

pub enum MyFirstActorMessage {
    /// 打印“Hello World”
    PrintHelloWorld,
    /// 回复已经打印的“Hello World”次数
    HowManyHelloWorlds(RpcReplyPort<u16>),
}

修改Actor定义​

pub struct MyFirstActor;

#[async_trait::async_trait]
impl Actor for MyFirstActor {
    type State = u16; // 状态为打印次数
    type Msg = MyFirstActorMessage;
    type Arguments = ();

    async fn pre_start(&self, _myself: ActorRef<Self::Msg>, _arguments: Self::Arguments)
        -> Result<Self::State, ActorProcessingErr>
    {
        Ok(0) // 初始状态为0
    }

    async fn handle(&self, _myself: ActorRef<Self::Msg>, message: Self::Msg, state: &mut Self::State) 
        -> Result<(), ActorProcessingErr>
    {
        match message {
            MyFirstActorMessage::PrintHelloWorld => {
                println!("Hello World!");
                *state += 1; // 增加打印次数
            }
            MyFirstActorMessage::HowManyHelloWorlds(reply) => {
                if reply.send(*state).is_err() {
                    println!("监听者在我们发送回复之前已经丢弃了端口");
                }
            }
        }
        Ok(())
    }
}

解析​

1. 状态定义：将State类型从()修改为u16，用于记录打印次数。
2. 消息类型扩展：添加HowManyHelloWorlds消息类型，包含一个RpcReplyPort<u16>，用于回复打印次数。
3. 处理消息：
   • PrintHelloWorld：打印“Hello World！”并增加状态中的计数。
   • HowManyHelloWorlds：通过reply.send方法回复当前的打印次数。

运行有状态的示例​

结合有状态的Actor，编写一个完整的程序，演示如何获取Actor的状态。

#[tokio::main]
async fn main() {
    // 启动Actor，并获取其引用和JoinHandle
    let (actor, actor_handle) = 
        Actor::spawn(None, MyFirstActor, ())
            .await
            .expect("Actor failed to start");
    
    for _ in 0..10 {
        // 发送打印消息
        actor.cast(MyFirstActorMessage::PrintHelloWorld)
            .expect("Failed to send message to actor");
    }

    // 发送查询消息，并等待回复，设置超时为100ms
    let hello_world_count = 
        ractor::call_t!(actor, MyFirstActorMessage::HowManyHelloWorlds, 100)
        .expect("RPC failed");
    
    println!("Actor replied with {} hello worlds!", hello_world_count);

    // 清理资源，停止Actor
    actor.stop(None);
    actor_handle.await.unwrap();
}

解析​

1. 启动Actor：与之前相同，启动MyFirstActor。
2. 发送消息：发送10条PrintHelloWorld消息，Actor会打印“Hello World！”并记录次数。
3. 查询状态：使用ractor::call_t!宏发送HowManyHelloWorlds消息，等待回复并获取打印次数。
4. 打印结果：输出Actor回复的打印次数。
5. 清理资源：停止Actor并等待其完成。

宏解释​

• cast!：发送消息而不等待回复，相当于actor.cast(MESG)。
• call!：发送消息并等待回复，相当于actor.call(|reply| MESG(reply))。
• call_t!：与call!类似，但带有超时参数，用于防止长时间等待。

总结​

通过本教程，我们学习了如何使用Ractor在Rust中实现Actor模型，涵盖了以下内容：

1. 基本概念：了解Actor模型及其在Rust中的实现。
2. 消息传递：掌握cast和call两种消息传递方式。
3. 安装Ractor：在项目中引入Ractor框架。
4. 创建第一个Actor：编写一个简单的打印“Hello World”的Actor。
5. 添加状态：扩展Actor以维护状态，并通过消息查询状态。
6. 运行示例：结合所有部分，编写并运行一个完整的有状态示例程序。

关键要点​

• Actor模型：一种并发编程模型，通过消息传递实现不同Actor之间的通信和协作。
• Ractor框架：受Erlang启发，提供高性能的Actor实现，构建于Tokio之上。
• 消息类型：使用枚举定义不同的消息类型，明确Actor可以处理的行为。
• 状态管理：Actor可以维护内部状态，并通过消息进行查询和更新。
• 宏工具：Ractor提供了便捷的宏，如cast!和call_t!，简化消息发送和回复的流程。

通过掌握这些内容，你可以在Rust中构建高效、可靠的并发应用，充分利用Rust的所有权和安全特性，编写出高质量的软件。

参考资料​

• Ractor 官方文档
• Tokio异步运行时

在本文中，我们将探讨Rust中的std::future::Future，深入了解其大小对性能和资源管理的影响，并分享一些优化Future大小的实用技巧。

引言​

Rust的异步编程模型依赖于Future，它代表一个可能尚未完成的计算。 理解Future的大小对于编写高效的异步代码至关重要，尤其是在资源有限的环境中，如嵌入式系统或高并发服务器。

本文将带你了解如何测量Future的大小、为什么这很重要，以及如何通过一些策略来优化Future的大小。

什么是Future？​

在Rust中，有两种创建Future的方法：

1. 手动实现：定义一个结构体或枚举，然后为其实现Future trait。
2. 使用async关键字：通过async块或async函数创建Future。 任何async块（async { .. }）或async函数（async fn foo() { .. }）都会返回一个Future。

例如：

async fn example_async_function() {
    // 异步操作
}

这个example_async_function函数返回一个Future，该Future在被poll时会执行其中的异步操作。

Future的大小有多大？​

在Rust中，Future的大小取决于它所包含的状态和数据。 编译器在编译时会确定每个Future的确切大小，这对于内存分配和性能优化非常重要。

如何测量Future的大小？​

可以使用std::mem::size_of函数来测量任何类型在内存中的大小。

对于Future，你可以创建一个通用的函数来获取其大小：

use std::future::Future;
use std::mem;

fn how_big_is_that_future<F: Future>(_fut: F) -> usize {
    mem::size_of::<F>()
}

#[tokio::main]
async fn main() {
    let fut = async {
        // 一些异步操作
    };
    println!("Future size: {} bytes", how_big_is_that_future(fut));
}

这个泛型函数会在编译时被具体化（monomorphised）， 即Rust编译器会为每种不同的F生成一个独立的函数版本，从而知道每个Future的具体大小。

为什么我们关心Future的大小？​

了解Future的大小对于以下几个方面至关重要：

1. 栈空间限制：Future通常在栈上分配，而每个线程的栈空间是有限的（例如，标准库中每个线程默认有2 MiB的栈空间）。
2. 性能优化：较大的Future会占用更多的内存，可能导致缓存未命中，影响性能。
3. 避免栈溢出：过大的Future可能导致栈空间耗尽，导致程序崩溃。

示例：大型Future​

以下是一个创建大型Future的示例：

async fn nothing() {}

async fn huge() {
    let mut a = [0_u8; 20_000];
    nothing().await;
    for (idx, item) in a.iter_mut().enumerate() {
        *item = (idx % 256) as u8;
    }
}

在这个示例中，huge函数创建了一个包含20,000个u8元素的数组，并在await点之后填充数组。 即使在发布模式下，这个Future也占用了20,002字节（20,000字节用于数组，2字节用于nothing函数的Future）。

如何优化Future的大小？​

1. 使用Box将Future放到堆上​

如果Future非常大，可以将其包装在Box中，将其存储在堆上，而不是栈上。

这样可以减少栈空间的占用。

async fn not_so_innocent() {
    Box::pin(huge()).await;
}

使用Box::pin而不是Box::new，因为Future需要被固定（pinned）以供轮询。

2. Tokio中的自动Boxing​

Tokio在编译为调试模式时，会检查用户提供的Future的大小，并在超过一定阈值时自动将其Box。 最新版本的Tokio还扩展了这一行为到发布模式，设置了16 KiB的限制。

tokio::spawn(huge());

通过这种方式，Tokio会自动将超过16 KiB的Future放到堆上，避免栈溢出。

3. 使用Tracing进行任务大小监控​

Tokio Console现在支持在任务生成时记录Future的大小，并提供警告以提示开发者可能存在的问题。

此外，Clippy已经引入了large_futures lint，可以在编译时检测过大的Future，帮助开发者在问题发生前进行优化。

完整示例​

以下是一个完整的示例，展示了如何测量和优化Future的大小：

use std::future::Future;
use std::mem;

fn how_big_is_that_future<F: Future>(_fut: F) -> usize {
    mem::size_of::<F>()
}

async fn nothing() {}

async fn huge() {
    let mut a = [0_u8; 20_000];
    nothing().await;
    for (idx, item) in a.iter_mut().enumerate() {
        *item = (idx % 256) as u8;
    }
}

#[tokio::main]
async fn main() {
    let fut = huge();
    println!("Future size: {} bytes", how_big_is_that_future(fut));

    tokio::spawn(fut);
}

运行上述代码，你将看到huge函数的Future大小，并且Tokio会根据配置自动将其Box到堆上。

总结​

了解和优化Future的大小对于编写高效、可靠的Rust异步代码至关重要。

通过以下几种方法，可以有效管理和减少Future的内存占用：

1. 测量Future的大小：使用std::mem::size_of函数。
2. Boxing大型Future：将其存储在堆上，减小栈空间占用。
3. 利用Tokio的自动Boxing：让Tokio自动处理大型Future。
4. 使用Clippy进行静态检查：提前发现并优化过大的Future。

通过这些策略，你可以确保Rust异步代码在各种环境下高效运行，避免内存和性能问题。

参考资料​

• Rust官方文档
• Tokio异步运行时
• Clippy工具
• Tokio Console

在现代编程中，异步编程已经成为提高程序性能和资源利用率的重要手段。 Rust作为一门系统级编程语言，提供了多种实现异步的方式。

本文将从概念入手，逐步深入探讨Rust中实现异步的各种方法，从标准库到第三方库， 全面介绍Rust的异步编程生态。

1. 异步编程的概念​

异步编程是一种允许多个任务并发执行而不需要多线程的编程范式。

它特别适用于I/O密集型任务，可以在等待I/O操作完成时执行其他任务，从而提高程序的整体效率。

在Rust中，异步编程主要围绕Future特征（trait）展开。 Future代表一个可能还未完成的异步操作，它定义了异步任务的行为。

2. 使用标准库实现异步​

2.1 手动实现Future特征​

最基本的异步实现方式是手动实现Future特征。 这种方法虽然较为底层，但能让我们深入理解Rust异步的工作原理。

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};

struct Delay {
    when: Instant,
}

impl Future for Delay {
    type Output = &'static str;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if Instant::now() >= self.when {
            println!("Future completed");
            Poll::Ready("done")
        } else {
            println!("Future not ready yet");
            cx.waker().wake_by_ref();
            Poll::Pending
        }
    }
}

#[tokio::main]
async fn main() {
    let future = Delay {
        when: Instant::now() + Duration::from_secs(2),
    };
    
    println!("Waiting...");
    let out = future.await;
    println!("Future returned: {}", out);
}

适用场景​

• 需要对异步操作有精细控制的场景
• 实现自定义的复杂异步原语
• 学习和理解Rust异步机制的底层原理

2.2 使用async/await语法​

Rust提供了async/await语法糖，使得编写异步代码变得更加简单和直观。

use tokio::time::{sleep, Duration};

async fn fetch_data(id: u32) -> String {
    sleep(Duration::from_millis(100)).await;
    format!("Data for id {}", id)
}

#[tokio::main]
async fn main() {
    let data1 = fetch_data(1).await;
    println!("Fetched: {}", data1);

    let results = tokio::join!(
        fetch_data(2),
        fetch_data(3),
        fetch_data(4)
    );

    println!("Fetched: {:?}", results);
}