从浅到深-Tokio强大的Rust异步框架，初步认识Tokio

大家好，我是梦兽编程。欢迎回来与梦兽编程一起刷Rust的系列。微信公众号【梦兽编程】即可加入梦兽编程微信交流群与我交流。

语言只是我们程序员实现途径中的工具，语言的生态丰富会让我们做起事来事半功倍。从今天开始我们开始进入Rust的生态学习。

异步是现在编写高性能应用的核心要素之一，很多语言都已经纷纷加入异步的特效。C#应该是最先做出响应的语言。连微软这位软件大佬都非常重视异步，可见异步编程重要性。

在Rust中同样支持异步编程，只不过一般我们不会使用Rust官方，而是使用第三方依赖Tokio。今天就我们进入新的篇章《Tokio从浅到深之旅》。

Tokio

Tokio 是一个用于 Rust 编程语言的异步运行时，它提供了一种在单线程中管理多个并发任务的方式。它是基于 Rust 的异步编程模型构建的，这个模型利用了 Rust 的所有权（ownership）和生命周期（lifetimes）特性来保证内存安全。

Tokio 的核心是它的异步 I/O 模型，它允许程序在执行 I/O 操作（如网络请求或文件读写）时不需要阻塞线程。

PS：如果你使用了Tokio，建议你还是使用tokio:io，而不是标准库std:io，这个看业务选择。

Tokio 还包括了一个事件循环（event loop），它负责调度和执行异步任务。这个事件循环可以处理成千上万的并发连接，所以Tokio非常适合用于构建高性能的网络应用，如 web 服务器、消息队列、实时通信系统等。

简单点说就是高性能中间件服务，例如Nginx这种服务基建。

同时，Tokio 还提供了许多实用的功能，如定时器、同步原语、TCP 和 UDP 网络协议等，以帮助开发者更轻松地构建复杂的网络应用。

基于Future实现

在Rust标准库中Future 是一个关键的概念，它是异步编程的基础。它代表了一个尚未完成的计算，可能在未来的某个时间点完成，并产生一个结果。

你可以完全类似的比作JavaScript中的Promise。

pub trait Future {
    type Output; // 关联类型，表示 Future 完成时产生的值类型

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

这里的 Poll 是一个枚举，它表示 poll 方法的可能结果：

pub enum Poll<T> {
    Ready(T),    // 异步操作已经完成，并返回一个值
    Pending,     // 异步操作尚未完成
}

这个 Future 对象可以被传递给执行上下文（如 Tokio 的运行时），执行上下文会定期调用 poll 方法来检查操作是否完成。如果操作完成，poll 方法会返回 Poll::Ready(result)，其中 result 是操作的结果。如果操作尚未完成，poll 方法会返回 Poll::Pending，并且当操作有可能完成时，通知执行上下文重新调度 Future。

几个简单的例子

由于今天我们是初步认识Tokio，下面的例子都比较简单，但可以让你快速熟悉tokio的基本用法。

use tokio::time::Duration; // 注意这里使用的tokio提供的time，并非std

#[tokio::main] //需要讲main函数设置为async并添加tokio::main注解
async fn main() {
    println!("Hello before delay");
    tokio::time::sleep(Duration::from_secs(2)).await;
    println!("Hello after delay");
}

TCP 客户端和服务端

// 服务端
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut buf = [0; 1024];
						// 只要你使用tokio，那边这个io也是异步读取的！！！
            match socket.read(&mut buf).await {
                Ok(n) if n == 0 => return,
                Ok(n) => {
                    println!("Received data: {}", String::from_utf8_lossy(&buf[..n]));
                }
                Err(e) => {
                    eprintln!("Failed to read from socket; error = {}", e);
                }
            }
        });
    }
}

// 客户端
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;

    stream.write_all(b"hello world").await?;

    Ok(())
}

使用 select! 宏处理多个异步操作

这个特效有点像Golang的并非处理，只是Rust 的异步编程模型基于 async/await 语法和 futures，而 Go 使用了基于协程（goroutines）和通道（channels）的模型。

//golang
select {
case msg1 := <-ch1:
    // 处理 msg1
case msg2 := <-ch2:
    // 处理 msg2
case <-time.After(time.Second):
    // 超时处理
default:
    // 默认情况
}

//rust
tokio::select! {
    Some(msg1) = receiver.recv() => {
        // 处理 msg1
    }
    Some(msg2) = receiver2.recv() => {
        // 处理 msg2
    }
    _ = tokio::time::sleep(Duration::from_secs(1)) => {
        // 超时处理
    }
}

如果您对Rust异步编程感兴趣，欢迎关注我的公众号【梦兽编程】，一起探索Rust的奥秘。如果您觉得这篇文章对您有帮助，请分享给更多需要的朋友。您的转发是我最大的动力！