O que é Tokio e Por Que Usar?
Tokio é um runtime assíncrono de alta performance para Rust, construído sobre a abstração de futures e async/await. Diferentemente de runtimes bloqueantes tradicionais, Tokio permite que múltiplas tarefas sejam executadas concorrentemente em um número reduzido de threads, maximizando a utilização de recursos. É a escolha padrão para aplicações web, sistemas distribuídos e qualquer cenário onde latência e throughput são críticos.
O grande diferencial do Tokio é sua capacidade de gerenciar milhares de conexões simultâneas sem criar uma thread por conexão. Você escreve código que parece síncrono, mas executa de forma assíncrona sob o capô, usando .await para pausar execução quando operações I/O são necessárias.
use tokio::task;
use tokio::time::{sleep, Duration};
#[tokio::main]
async fn main() {
let handle = task::spawn(async {
sleep(Duration::from_secs(2)).await;
println!("Tarefa completada!");
});
handle.await.unwrap();
}
Arquitetura e Componentes Fundamentais
Work-Stealing Scheduler
Tokio utiliza um scheduler baseado em work-stealing, onde múltiplas worker threads roubam trabalho uma da outra quando ficam ociosas. Isso distribui carga de forma eficiente sem overhead de sincronização excessiva. Por padrão, Tokio cria uma thread por núcleo de CPU, mas isso é configurável.
Task Spawning e Concorrência
Tasks são unidades de trabalho leves que podem ser spawned para execução concorrente. Diferente de threads do SO, tasks têm overhead mínimo. Use tokio::spawn para criar novas tasks ou tokio::task::block_in_place quando precisar executar código síncrono.
use tokio::task;
#[tokio::main]
async fn main() {
let mut handles = vec![];
for i in 0..5 {
let handle = task::spawn(async move {
println!("Task {}", i);
i * 2
});
handles.push(handle);
}
for handle in handles {
let resultado = handle.await.unwrap();
println!("Resultado: {}", resultado);
}
}
Padrões Práticos: Sync, Select e Timeouts
Synchronization com Canais
Tokio fornece mpsc (multi-producer, single-consumer) para comunicação entre tasks. Use canais quando multiple tasks precisam enviar dados para um consumer central.
use tokio::sync::mpsc;
#[tokio::main]
async fn main() {
let (tx, mut rx) = mpsc::channel(100);
tokio::spawn(async move {
for i in 0..5 {
tx.send(i).await.unwrap();
}
});
while let Some(valor) = rx.recv().await {
println!("Recebido: {}", valor);
}
}
Select para Múltiplas Operações
O macro tokio::select! permite aguardar múltiplas futures simultaneamente, respondendo ao primeiro resultado. Essencial para timeouts, graceful shutdown e multiplexação.
use tokio::time::{sleep, Duration};
#[tokio::main]
async fn main() {
let mut counter = 0;
loop {
tokio::select! {
_ = sleep(Duration::from_secs(1)) => {
counter += 1;
println!("Tick {}", counter);
if counter >= 3 { break; }
}
}
}
}
Timeouts Robustos
Sempre use timeouts em operações I/O para evitar deadlocks infinitos. tokio::time::timeout encapsula uma future com limite de tempo.
use tokio::time::{timeout, Duration};
#[tokio::main]
async fn main() {
let resultado = timeout(
Duration::from_secs(2),
sua_operacao_demorada()
).await;
match resultado {
Ok(Ok(value)) => println!("Sucesso: {}", value),
Ok(Err(e)) => println!("Erro na operação: {}", e),
Err(_) => println!("Timeout!"),
}
}
async fn sua_operacao_demorada() -> Result<String, String> {
Ok("dados".to_string())
}
Aplicação Real: Servidor HTTP Assíncrono
Combinando conhecimento anterior, vamos construir um servidor que demonstra os padrões aprendidos. Aqui usamos hyper (que roda sobre Tokio) para aceitar requisições, processar tasks paralelas e responder com timeout.
use hyper::{Body, Request, Response, Server, StatusCode};
use std::convert::Infallible;
use tokio::time::{timeout, Duration};
async fn handle_request(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
let resultado = timeout(Duration::from_secs(5), processar_requisicao()).await;
let resposta = match resultado {
Ok(Ok(data)) => Response::new(Body::from(data)),
Ok(Err(_)) => Response::builder()
.status(StatusCode::INTERNAL_SERVER_ERROR)
.body(Body::from("Erro no processamento"))
.unwrap(),
Err(_) => Response::builder()
.status(StatusCode::GATEWAY_TIMEOUT)
.body(Body::from("Timeout"))
.unwrap(),
};
Ok(resposta)
}
async fn processar_requisicao() -> Result<String, Box<dyn std::error::Error>> {
tokio::time::sleep(Duration::from_millis(100)).await;
Ok("OK".to_string())
}
#[tokio::main]
async fn main() {
let addr = ([127, 0, 0, 1], 3000).into();
let server = Server::bind(&addr)
.serve(hyper::service::make_service_fn(|_conn| async {
Ok::<_, Infallible>(hyper::service::service_fn(handle_request))
}));
println!("Servidor rodando em {}", addr);
server.await.unwrap();
}
Conclusão
Tokio é essencial para Rust moderno em produção. Os três pontos-chave para dominar: primeiro, entenda que .await não bloqueia threads, apenas pausar a execução da task individual; segundo, sempre use timeouts em I/O para sistemas robusto; terceiro, leverage work-stealing scheduler spawning muitas tasks leves em vez de poucas threads pesadas. Começar com exemplos simples e evoluir para padrões como canais e select é o caminho mais seguro para proficiência.