Rust / 系统课时

使用 AsyncRead 与 AsyncWrite

使用 AsyncRead 与 AsyncWrite

Tokio 的异步 I/O 不保证一次调用就读满或写完指定数据。要写出可靠的协议处理代码,需要正确使用 AsyncReadExt、AsyncWriteExt,把部分读写、flush、EOF 和错误都当成正常控制流的一部分。本节用内存双工流完成一个可直接运行的读写示例。

学习目标

  • 使用 AsyncReadExt 与 AsyncWriteExt 完成异步读取、完整写入、刷新和关闭写端。
  • 正确处理 read 的部分读取与返回 0 表示的 EOF。
  • 区分 write、write_all、flush 的语义,并识别错误发生后的重试风险。

扩展 trait 提供了什么

AsyncRead 与 AsyncWrite 定义底层轮询接口,日常业务代码通常通过扩展 trait 获得 .read()、.write_all()、.flush() 等 async 友好方法。关键点不是记住方法名,而是接受 I/O 的“部分完成”语义:一次 read 可能只返回缓冲区的一部分,一次 write 也可能只写入部分字节。

write_all 会内部重复调用写操作,直到整个缓冲区写完或遇到错误;flush 请求把用户态或中间缓冲中的数据继续向底层推进,但它不等于“对端应用已经读取并处理”。读取端使用非空缓冲区时,read 返回 0 才表示已经到达 EOF。

Tokio 异步读写中的部分传输与 EOF

完成一次可靠的读写

下面使用 tokio::io::duplex 创建内存中的双工流,不依赖端口或外部服务器,因此可以直接复现。依赖配置如下:

toml
[package]
name = "tokio-io-demo"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

写端分两次写入数据,随后 flush 并 shutdown。读端故意只使用 4 字节缓冲区,通过循环处理任意大小的部分读取,直到看到 EOF。

rust
use std::error::Error;
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 小容量双工流让读写双方真正并发推进,而不是一次性缓存全部数据。
    let (mut reader, mut writer) = io::duplex(8);

    let producer = tokio::spawn(async move {
        writer.write_all(b"hello ").await?;
        writer.write_all(b"tokio").await?;
        writer.flush().await?;
        // 关闭写方向后,读端在消费完剩余字节后才能观察到 EOF。
        writer.shutdown().await?;
        Ok::<(), io::Error>(())
    });

    let mut chunk = [0_u8; 4];
    let mut body = Vec::new();

    let eof = loop {
        let n = reader.read(&mut chunk).await?;
        if n == 0 {
            break true;
        }

        // 只追加本次实际读到的区间,不能把整个缓冲区都当成有效数据。
        body.extend_from_slice(&chunk[..n]);
    };

    producer.await??;

    println!("body:{}", String::from_utf8(body)?);
    println!("eof:{eof}");
    Ok(())
}

在项目根目录执行:

bash
cargo run --quiet

预期输出

text
body:hello tokio
eof:true

正确处理部分读写

不要把“一次 read”等同于“一条完整消息”。TCP、管道和很多异步流都只提供字节流语义,当前能拿到多少字节取决于缓冲、调度和对端发送进度。示例用 &chunk[..n] 只消费实际读取的部分,然后继续循环,最终才能得到完整内容。

写入也有同样问题。若调用低层 .write(),返回值可能小于缓冲区长度,调用者必须继续处理剩余字节。普通“整段发送”场景优先使用 .write_all();如果协议需要背压控制或自行维护发送队列,再显式处理每次写入的字节数。

EOF、flush 与错误边界

对非空缓冲区,read 返回 0 表示输入流已经结束。示例中的 EOF 来自写端 shutdown():写方向关闭后,读端消费完剩余数据,再次读取就得到 0。如果连接是长期存活协议,就不能使用“等 EOF”来划分每条消息,而应使用长度前缀、分隔符或专门的帧编解码层。

flush() 的职责是把已缓冲的写入继续推向底层 I/O,它不是远端确认。真正需要“对端已处理”的语义时,协议必须定义 ACK 或响应消息。错误也要结合进度判断:write_all 在中途失败时,前面部分字节可能已经写出,直接从头重试可能造成重复数据。

异步 I/O 的核心不是“把同步方法换成 .await”,而是让代码显式接受部分完成、EOF 和错误边界。只要协议边界清楚,AsyncReadExt 与 AsyncWriteExt 就能把底层轮询细节压缩成可维护的异步控制流。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

使用 AsyncRead 与 AsyncWrite

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通