0Pricing
Learn Rust Coding · Aula

Introdução a Async/Await

Aprenda os fundamentos das funções `async` e das expressões `await` para escrever código assíncrono e não bloqueante.

Introdução a Async/Await é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 3 aulas no total.

Por que a Programação Assíncrona?

Na programação, as tarefas frequentemente envolvem espera. Pode ser esperar um arquivo carregar, uma solicitação de rede ser concluída ou uma consulta ao banco de dados retornar resultados.

Tradicionalmente, os programas bloqueiam durante essas esperas, ou seja, pausam todas as outras operações até que a tarefa termine. Isso pode deixar as aplicações lentas e sem resposta.

Quando o Código Espera...

Considere este exemplo simples de uma operação bloqueante. O programa fará uma pausa de 2 segundos antes de imprimir a segunda mensagem.

Experimente executá-lo:

use std::thread;
use std::time::Duration;

fn main() {
  println!("Starting a blocking task...");
  thread::sleep(Duration::from_secs(2)); // This blocks!
  println!("Blocking task finished!");
}

O Custo da Espera

No exemplo anterior, o programa inteiro esperou. Se isso fosse um servidor web, significaria que, enquanto a solicitação de um usuário estivesse esperando pelo banco de dados, nenhum outro usuário poderia ser atendido!

A programação assíncrona permite que seu programa inicie uma tarefa demorada e passe a trabalhar em outra coisa em vez de esperar. Quando a tarefa longa estiver pronta, o programa poderá retomá-la.

A Abordagem Assíncrona do Rust

O Rust oferece recursos avançados de linguagem para programação assíncrona: as palavras-chave async e await.

  • As funções async são funções especiais que podem ser pausadas e retomadas.
  • .await é usado dentro de uma função async para esperar a conclusão de outra tarefa assíncrona sem bloquear o programa inteiro.

Definindo Funções `async`

Você declara uma função assíncrona adicionando a palavra-chave async antes de fn. Uma função async sempre retorna um futuro.

Um futuro é um valor que talvez ainda não esteja pronto. Ele representa um cálculo que produzirá um resultado eventualmente.

async fn my_async_task() -> u32 {
  // This task will eventually return 42
  42
}

Pausando com `.await`

A palavra-chave .await é o que torna a programação assíncrona não bloqueante. Quando você usa .await em um futuro, sua função async irá:

  • Pausar sua própria execução.
  • Permitir que o programa faça outro trabalho.
  • Retomar a execução quando o futuro aguardado estiver pronto.

É como pressionar o botão de pausa da tarefa atual enquanto outra tarefa é concluída.

Executando Código Assíncrono: Executores

Uma função async retorna um futuro, mas não executa imediatamente o código dentro dela. Futuros são preguiçosos.

Para realmente executar uma função async e executar seu futuro, você precisa de um executor. Em exemplos simples, podemos usar futures::executor::block_on, que executa um futuro até a conclusão na thread atual.

Seu Primeiro Programa `async`/`await`

Veja como async, await e um executor simples trabalham juntos. Observe como block_on é usado em main para iniciar o processo assíncrono.

Este exemplo simula um atraso assíncrono sem bloquear a thread da função main (conceitualmente; o próprio block_on bloqueia até que o futuro termine, mas a tarefa assíncrona cede o controle).

use futures::executor::block_on;
use std::time::Duration;

async fn learn_and_wait() {
  println!("Learning asynchronously...");
  // Simulate an async operation that takes time
  // In a real app, this would be an I/O op
  tokio::time::sleep(Duration::from_secs(1)).await;
  println!("Finished learning!");
}

fn main() {
  println!("Starting main function.");
  block_on(learn_and_wait());
  println!("Main function finished.");
}

Entendendo o Trait `Future`

Quando você escreve async fn my_func(), o Rust na verdade o transforma em uma máquina de estados que implementa o trait Future.

O trait Future tem um método principal, poll, que um executor chama repetidamente para verificar se a tarefa está pronta para avançar. Quando um futuro recebe .await, ele informa ao executor que deve consultar outro futuro até que ele termine.

Verificação Rápida: Noções Básicas de Async/Await

Você aprendeu o básico de async e await. Vamos verificar se você consegue identificar as funções principais.

Recapitulação e Próximos Passos

Parabéns! Você deu os primeiros passos na programação assíncrona com Rust.

  • Vimos que o código síncrono bloqueia, fazendo os programas esperar.
  • O código assíncrono permite que as tarefas sejam executadas concorrentemente sem bloqueio.
  • A palavra-chave async declara uma função assíncrona, que retorna um futuro.
  • A palavra-chave .await pausa uma função async até que um futuro esteja pronto.
  • É necessário um executor (como block_on) para executar futuros.

Em seguida, vamos conhecer o Tokio, um ambiente de execução e ecossistema avançados para criar aplicações assíncronas reais em Rust!

Perguntas Frequentes

A aula “Introdução a Async/Await” é grátis?

Sim — o texto completo de “Introdução a Async/Await” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 3 aulas no total.

O que vou aprender em “Introdução a Async/Await”?

Aprenda os fundamentos das funções `async` e das expressões `await` para escrever código assíncrono e não bloqueante. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “Introdução a Async/Await”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Introdução a Async/Await
  2. Criação de Aplicações Assíncronas com Tokio
  3. Trabalho com Futuros e Tarefas
← Voltar para Learn Rust Coding