I/O Assíncrono

Tokio encapsula o I/O assíncrono do sistema operacional (epoll, kqueue, IOCP) para sockets e arquivos. Use as traits AsyncRead/AsyncWrite e helpers com buffer para código de rede e arquivo eficiente.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
 
#[tokio::main]
async fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    stream.write_all(b"GET /\r\n\r\n").await?;
    let mut buf = vec![0u8; 1024];
    let n = stream.read(&mut buf).await?;
    println!("leu {n} bytes");
    Ok(())
}

Quando usar isso: Servidores TCP/UDP, clientes HTTP, streaming de arquivos e qualquer protocolo baseado em socket.

Exemplo de Trabalho

use tokio::io::{AsyncBufReadExt, BufReader};
use tokio::fs::File;
 
#[tokio::main]
async fn main() -> std::io::Result<()> {
    let file = File::open("/etc/hosts").await?;
    let mut reader = BufReader::new(file);
    let mut line = String::new();
 
    while reader.read_line(&mut line).await? > 0 {
        if line.starts_with('#') {
            line.clear();
            continue;
        }
        println!("{}", line.trim());
        line.clear();
    }
    Ok(())
}

O que isso demonstra:

• tokio::fs::File para abrir arquivos de forma assíncrona.
• BufReader reduz a contagem de chamadas de sistema para leituras de linha.
• read_line retorna 0 no final do arquivo (EOF).

Mergulho Profundo

Como Funciona

• Reactor: O sistema operacional notifica o Tokio quando sockets/arquivos estão legíveis/graváveis.
• AsyncRead/AsyncWrite: poll_read/poll_write integram-se com os "wakers".
• I/O com Buffer: BufReader/BufWriter agrupam pequenas leituras/escritas.
• Split: split() separa as metades de leitura/escrita para direções concorrentes.

Tipos Comuns

Notas de Rust

use tokio::io::copy;
use tokio::fs::File;
 
async fn copy_file(src: &str, dst: &str) -> std::io::Result<u64> {
    let mut reader = File::open(src).await?;
    let mut writer = File::create(dst).await?;
    copy(&mut reader, &mut writer).await
}

• Prefira reqwest/hyper para HTTP em vez de TCP bruto para código de aplicação.
• Defina nodelay do TCP e tamanhos de buffer para serviços sensíveis à latência.
• Use tokio::net::lookup_host para DNS assíncrono.

Armadilhas

• Pequenos loops de leitura sem buffer - Chamada de sistema por byte mata a taxa de transferência. Correção: BufReader ou buffers fixos maiores.
• std::fs no manipulador assíncrono - Bloqueia o worker. Correção: tokio::fs ou spawn_blocking.
• Esquecer flush no BufWriter - Dados presos no buffer. Correção: flush().await antes de fechar.
• Loop de accept sem spawn - Serializa conexões. Correção: spawn por conexão ou use Axum.
• Buffer de recebimento UDP muito pequeno - Trunca datagramas. Correção: Tamanho do buffer para MTU/máximo da aplicação.

Alternativas

FAQs

Relacionados

• Tokio Basics - Exemplo TCP
• Streams - Streams de bytes como Stream
• Blocking in Async - Armadilhas de I/O de arquivo
• select! & Concorrência - Multiplexação de I/O
• Graceful Shutdown - Drenagem de conexões

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.