0Pricing
Learn Rust Coding · Aula

Criação de Aplicações Assíncronas com Tokio

Utilize o ambiente de execução Tokio para executar tarefas assíncronas de forma eficiente, gerindo E/S e outras operações concorrentes.

Criação de Aplicações Assíncronas com Tokio é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 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.

Conheça o Ambiente de Execução Tokio

Bem-vindo de volta! Na lição anterior, você aprendeu sobre async e await. Mas como uma função async é realmente executada?

É aí que entra um ambiente de execução assíncrono, como o Tokio. Tokio é uma biblioteca avançada que fornece o ambiente de execução para seu código assíncrono em Rust.

  • Ele agenda e executa Futures.
  • Lida com operações de E/S não bloqueantes.
  • Gerencia tarefas concorrentes com eficiência.

Executando Seu Código Assíncrono

Para começar a usar o Tokio, normalmente você utiliza a macro de atributo #[tokio::main]. Essa macro transforma sua async fn main() em uma fn main() padrão, que inicializa o ambiente de execução Tokio e executa seu código assíncrono.

Pense nela como o ponto de entrada da sua aplicação assíncrona.

use tokio;

#[tokio::main]
async fn main() {
  println!("Hello from Tokio!");
}

Criando Novas Tarefas Assíncronas

Um dos principais recursos do Tokio é a capacidade de executar várias operações assíncronas concorrentemente. Você pode fazer isso usando tokio::spawn.

tokio::spawn recebe um Future e o agenda para execução no ambiente de execução Tokio. Isso permite que sua tarefa principal continue sendo executada enquanto a tarefa criada é executada em segundo plano.

  • Ela não bloqueia.
  • Retorna um JoinHandle para aguardar sua conclusão.
  • As tarefas são executadas de forma independente.

<code>tokio::spawn</code> em Ação

Veja como tokio::spawn permite executar código concorrentemente. Observe que as duas mensagens aparecem, mas a mensagem 'concluído' pode ser impressa antes da mensagem 'tarefa concluída' devido à pausa.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  // Spawn a new task
  let handle = tokio::spawn(async {
    sleep(Duration::from_secs(1)).await;
    println!("Async task complete!");
  });

  println!("Main task continuing...");

  // Wait for the spawned task to finish
  handle.await.unwrap();
  println!("All tasks done.");
}

Esperando Várias Tarefas

Quando você tem várias tarefas, geralmente precisa esperar que todas sejam concluídas. O Tokio fornece a macro tokio::join! para essa finalidade.

tokio::join! permite aguardar concorrentemente vários futuros e combinar seus resultados. É semelhante a usar `await` em vários JoinHandles, mas geralmente é mais conciso para conjuntos fixos de futuros.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  let task1 = async {
    sleep(Duration::from_secs(1)).await;
    println!("Task 1 finished");
    1
  };

  let task2 = async {
    sleep(Duration::from_millis(500)).await;
    println!("Task 2 finished");
    2
  };

  let (result1, result2) = tokio::join!(task1, task2);
  println!("Results: {}, {}", result1, result2);
}

E/S Assíncrona de Arquivos com Tokio

As operações tradicionais de arquivos podem bloquear a thread, o que é ruim para aplicações assíncronas. O módulo tokio::fs do Tokio fornece versões assíncronas das operações do sistema de arquivos.

Isso permite que sua aplicação continue responsiva mesmo ao ler arquivos grandes ou realizar muitas operações de arquivo, pois a E/S é tratada de maneira não bloqueante.

  • tokio::fs::read_to_string
  • tokio::fs::write
  • tokio::fs::File para obter mais controle

Lendo um Arquivo de Forma Assíncrona

Veja como ler um arquivo de forma assíncrona usando tokio::fs::read_to_string. Para que esse código seja executado, certifique-se de que há um arquivo chamado hello.txt no mesmo diretório do seu projeto Rust (por exemplo, dentro de src/ ou na raiz do projeto) com algum conteúdo.

use tokio::fs;

#[tokio::main]
async fn main() {
  let path = "hello.txt";
  // Create a dummy file for the example if it doesn't exist
  // In a real app, you'd handle file creation/existence more robustly
  if let Err(_) = fs::metadata(path).await {
    fs::write(path, "Hello, Tokio file!").await.unwrap();
  }

  match fs::read_to_string(path).await {
    Ok(content) => println!("File content: '{}'", content),
    Err(e) => eprintln!("Error reading file: {}", e),
  }
}

Operações de Rede Assíncronas

O Tokio realmente se destaca na programação de redes. Seu módulo tokio::net oferece primitivas não bloqueantes para comunicação TCP e UDP.

Isso é essencial para criar servidores ou clientes de alto desempenho capazes de lidar com muitas conexões simultaneamente, sem uma thread separada para cada uma.

  • tokio::net::TcpListener para servidores.
  • tokio::net::TcpStream para conexões de clientes.

Estrutura Básica de um Servidor TCP Assíncrono

Embora um servidor completo seja complexo, este trecho mostra o ciclo principal de um servidor TCP assíncrono usando Tokio. Ele aguarda conexões recebidas e imprime uma mensagem para cada uma. Experimente executá-lo e, em seguida, abra seu navegador em http://127.0.0.1:8080 para ver as conexões.

use tokio::net::TcpListener;

#[tokio::main]
async fn main() {
  let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
  println!("Listening on: {}", listener.local_addr().unwrap());

  loop {
    let (socket, addr) = listener.accept().await.unwrap();
    println!("Accepted connection from: {}", addr);
    // In a real server, you'd spawn a task to handle the socket
    // tokio::spawn(async move { handle_connection(socket).await; });
  }
}

// fn handle_connection(socket: TcpStream) { /* ... */ } // Placeholder

Desafio de Tarefas do Tokio

Considere o seguinte código Rust usando Tokio. Qual será a primeira mensagem exibida no console quando este programa for executado?

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  tokio::spawn(async {
    sleep(Duration::from_millis(200)).await;
    println!("Task 1: Done");
  });

  tokio::spawn(async {
    sleep(Duration::from_millis(100)).await;
    println!("Task 2: Done");
  });

  println!("Main: Starting tasks...");

  sleep(Duration::from_millis(300)).await;
  println!("Main: Finishing.");
}

Recapitulação: compilando com Tokio

Você deu um passo importante na criação de aplicações assíncronas com Rust e Tokio!

  • Tokio atua como o ambiente de execução assíncrono, executando seu código async.
  • #[tokio::main] é o ponto de entrada assíncrono do seu programa.
  • tokio::spawn permite executar várias tarefas simultaneamente.
  • tokio::join! ajuda a aguardar vários futuros.
  • Tokio fornece E/S não bloqueante para arquivos (tokio::fs) e redes (tokio::net).

Essas ferramentas são fundamentais para criar aplicações altamente concorrentes e responsivas em Rust. Continue praticando!

Perguntas Frequentes

A aula “Criação de Aplicações Assíncronas com Tokio” é grátis?

Sim — o texto completo de “Criação de Aplicações Assíncronas com Tokio” é 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 “Criação de Aplicações Assíncronas com Tokio”?

Utilize o ambiente de execução Tokio para executar tarefas assíncronas de forma eficiente, gerindo E/S e outras operações concorrentes. 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 2 de 3.

Quanto tempo leva a aula “Criação de Aplicações Assíncronas com Tokio”?

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