---
title: "Async/Await Rust em Profundidade | Rust Brasil"
url: "https://rustlang.com.br/artigos/async-await-profundidade/"
markdown_url: "https://rustlang.com.br/artigos/async-await-profundidade.MD"
description: "Async/await em Rust: futures, pinning, wakers, executors e como o runtime funciona. Guia avançado em português."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---
# Async/Await Rust em Profundidade | Rust Brasil
Async/await em Rust: futures, pinning, wakers, executors e como o runtime funciona. Guia avançado em português.
A programação assíncrona em Rust é poderosa, mas funciona de forma fundamentalmente diferente de outras linguagens. Enquanto JavaScript e Python usam um runtime integrado à linguagem, o Rust define apenas os **primitivos** (`Future`, `async`, `await`) e delega a execução a runtimes externos como Tokio. Go resolve o mesmo problema de forma completamente diferente com goroutines — compare com goroutines, channels e pipelines em Go. Neste artigo, vamos abrir o capô e entender como tudo funciona por dentro — de futures até o mecanismo de polling.
## O Que É uma Future?
No centro do async Rust está o trait `Future`:
```rust
use std::pin::Pin;
use std::task::{Context, Poll};
// Definição simplificada
trait Future {
type Output;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll;
}
// Poll é um enum simples
enum Poll {
Ready(T), // Resultado pronto
Pending, // Ainda não terminou
}
```
Uma future é uma **computação que pode não ter terminado ainda**. Cada chamada a `poll()` tenta avançar a computação:
```
Ciclo de vida de uma Future:
┌─────────┐
│ Criada │
└────┬─────┘
│
┌──────────────▼──────────────┐
│ poll() chamado │
└──────────────┬──────────────┘
│
┌──────────┴──────────┐
│ │
┌─────▼─────┐ ┌─────▼─────┐
│ Pending │ │ Ready(T) │
│(registra │ │ (concluído)│
│ Waker) │ └────────────┘
└─────┬──────┘
│
│ Waker notifica
│
▼
poll() novamente...
```
## Como `async`/`await` Se Transforma em Futures
Quando você escreve uma função `async`, o compilador a transforma em uma **máquina de estados**:
```rust
// O que você escreve:
async fn buscar_dados(url: &str) -> String {
let resposta = fazer_requisicao(url).await;
let texto = processar(resposta).await;
texto.to_uppercase()
}
// O que o compilador gera (conceitualmente):
// enum BuscarDadosFuture {
// Estado0 { url: String }, // antes do primeiro await
// Estado1 { url: String, fut: RequisicaoFuture }, // esperando requisição
// Estado2 { fut: ProcessarFuture }, // esperando processamento
// Completo,
// }
//
// impl Future for BuscarDadosFuture {
// type Output = String;
// fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll {
// match self.estado {
// Estado0 => { /* inicia requisição, vai para Estado1 */ }
// Estado1 => { /* poll requisição, se Ready vai para Estado2 */ }
// Estado2 => { /* poll processamento, se Ready retorna resultado */ }
// }
// }
// }
```
Cada `.await` é um ponto de suspensão onde a future pode retornar `Pending` e ser retomada depois.
## Implementando uma Future Manual
Vamos criar uma future simples para entender o mecanismo:
```rust
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};
struct Temporizador {
quando: Instant,
}
impl Temporizador {
fn novo(duracao: Duration) -> Self {
Temporizador {
quando: Instant::now() + duracao,
}
}
}
impl Future for Temporizador {
type Output = String;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll {
if Instant::now() >= self.quando {
Poll::Ready("Temporizador concluído!".to_string())
} else {
// Registrar waker para ser notificado depois
let waker = cx.waker().clone();
let quando = self.quando;
// Em um runtime real, registraríamos com o reactor
// Aqui, simulamos com uma thread
std::thread::spawn(move || {
let agora = Instant::now();
if quando > agora {
std::thread::sleep(quando - agora);
}
waker.wake(); // Notifica o runtime para poll() novamente
});
Poll::Pending
}
}
}
#[tokio::main]
async fn main() {
println!("Iniciando temporizador...");
let resultado = Temporizador::novo(Duration::from_secs(1)).await;
println!("{}", resultado);
}
```
## Pin: Por Que Futures Precisam Ser Fixadas
`Pin<&mut Self>` na assinatura de `poll()` garante que a future não seja movida na memória. Isso é necessário porque futures podem conter **auto-referências**:
```rust
// Esta async fn gera uma future com auto-referência:
async fn auto_referencia() {
let dados = vec![1, 2, 3];
let referencia = &dados; // referência a dados — auto-referência na future!
println!("{:?}", referencia);
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
// Após o await, 'referencia' ainda aponta para 'dados'
// Se a future fosse movida, o ponteiro ficaria inválido!
println!("{:?}", referencia);
}
```
### Layout de Memória e o Problema do Move
```
Antes do move (endereço 0x1000):
┌──────────────────────────────┐
│ dados: [1, 2, 3] @ 0x1000 │
│ referencia: ptr → 0x1000 │ ← aponta para si mesmo
└──────────────────────────────┘
Após move (endereço 0x2000):
┌──────────────────────────────┐
│ dados: [1, 2, 3] @ 0x2000 │
│ referencia: ptr → 0x1000 │ ← ponteiro INVÁLIDO!
└──────────────────────────────┘
Com Pin: a future fica fixada e não pode ser movida.
```
### Usando Pin na Prática
```rust
use std::pin::Pin;
use std::future::Future;
// Ao armazenar futures em structs, use Pin>
struct TarefasPendentes {
tarefas: Vec + Send>>>,
}
impl TarefasPendentes {
fn nova() -> Self {
TarefasPendentes { tarefas: Vec::new() }
}
fn adicionar(&mut self, tarefa: impl Future