Os modelos de programação síncrona tradicionais frequentemente levam a estrangulamentos de desempenho. Isso acontece porque o programa aguarda a finalização de operações lentas para prosseguir para a próxima tarefa. Geralmente, isso resulta em um uso ineficiente de recursos e uma experiência do usuário morosa.
A programação assíncrona permite a criação de código não bloqueante que utiliza os recursos do sistema de forma eficaz. Ao aproveitar a programação assíncrona, você pode construir aplicativos que executam múltiplas tarefas simultaneamente. Este tipo de programação é particularmente útil para gerenciar diversas requisições de rede ou processar grandes volumes de dados sem interromper o fluxo de execução.
Programação Assíncrona em Rust
O paradigma de programação assíncrona em Rust permite que você escreva um código eficiente que opera simultaneamente sem bloquear o fluxo de execução. A programação assíncrona é vantajosa ao lidar com operações de E/S, requisições de rede e tarefas que envolvem a espera por recursos externos.
Você pode implementar a programação assíncrona em seus aplicativos Rust de várias maneiras. Isso inclui recursos da linguagem, bibliotecas e o ambiente de execução Tokio.
Ademais, o sistema de propriedade do Rust e suas ferramentas de simultaneidade, como canais e bloqueios, possibilitam uma programação simultânea segura e eficiente. Você pode utilizar esses recursos com a programação assíncrona para desenvolver sistemas concorrentes que escalam bem e utilizam múltiplos núcleos de CPU.
Conceitos de Programação Assíncrona em Rust
Futures (Promessas) formam a base da programação assíncrona em Rust. Um Future representa uma computação assíncrona que ainda não foi totalmente executada.
Futures são “lazy”, ou seja, só são executados quando explicitamente solicitados. Ao invocar o método poll() de um Future, o sistema verifica se a computação foi concluída ou se precisa de mais trabalho. Se o Future não estiver pronto, ele retorna Poll::Pending, indicando que a tarefa deve ser reagendada para execução posterior. Se o Future estiver pronto, ele retorna Poll::Ready com o valor resultante.
O conjunto de ferramentas padrão do Rust inclui primitivas de E/S assíncronas, que são versões assíncronas de operações de arquivo, rede e temporizadores. Essas primitivas possibilitam a execução de operações de E/S de forma assíncrona, prevenindo o bloqueio da execução do programa enquanto se aguarda a conclusão de tarefas de E/S.
A sintaxe async/await permite escrever código assíncrono de forma similar ao código síncrono, tornando seu código mais intuitivo e fácil de manter.
A abordagem do Rust para a programação assíncrona enfatiza segurança e desempenho. As regras de propriedade e borrowing garantem a segurança da memória e evitam problemas comuns de concorrência. A sintaxe async/await e os Futures fornecem uma maneira intuitiva de expressar fluxos de trabalho assíncronos. Você pode utilizar um ambiente de execução de terceiros para gerenciar tarefas para uma execução eficiente.
Combinando esses recursos de linguagem, bibliotecas e ambientes de execução, é possível criar código de alto desempenho, fornecendo uma estrutura robusta e ergonômica para a construção de sistemas assíncronos. Isso faz do Rust uma escolha popular para projetos que exigem tratamento eficiente de tarefas dependentes de E/S e alta simultaneidade.
As versões do Rust 1.39 e posteriores não suportam operações assíncronas na biblioteca padrão. É necessário usar uma crate de terceiros para empregar a sintaxe async/await e lidar com operações assíncronas em Rust. Pacotes como Tokio ou async-std podem ser utilizados para trabalhar com essa sintaxe.
Programação Assíncrona com Tokio
Tokio é um ambiente de execução assíncrono robusto para Rust. Ele fornece funcionalidades para criar aplicativos escaláveis e de alto desempenho. Ao utilizar Tokio, você pode aproveitar o poder da programação assíncrona. Além disso, oferece recursos para extensibilidade.
O núcleo do Tokio reside em seu modelo de execução e agendamento de tarefas assíncronas. Tokio permite escrever código assíncrono com a sintaxe async/await, possibilitando a utilização eficiente dos recursos do sistema e a execução simultânea de tarefas. O loop de eventos do Tokio gerencia o agendamento de tarefas de forma eficaz, garantindo a utilização otimizada dos núcleos da CPU e minimizando a sobrecarga de troca de contexto.
Os combinadores do Tokio facilitam a coordenação e composição de tarefas. Tokio oferece ferramentas poderosas para coordenação e composição de tarefas. Você pode aguardar que múltiplas tarefas sejam finalizadas com join, selecionar a primeira tarefa concluída com select e executar tarefas em concorrência com race.
Adicione a crate tokio na seção de dependências do seu arquivo Cargo.toml:
[dependencies]
tokio = { version = "1.9", features = ["full"] }
Veja como você pode utilizar a sintaxe async/await em seus programas Rust com Tokio:
use tokio::time::sleep;
use std::time::Duration;
async fn hello_world() {
println!("Olá, ");
sleep(Duration::from_secs(1)).await;
println!("Mundo!");
}
#[tokio::main]
async fn main() {
hello_world().await;
}
A função hello_world é assíncrona e, portanto, pode utilizar a palavra-chave await para pausar sua execução até que um Future seja resolvido. A função hello_world imprime “Olá,” no console. A chamada da função Duration::from_secs(1) suspende a execução da função por um segundo. A palavra-chave await espera a conclusão do Future de suspensão. Finalmente, a função hello_world imprime “Mundo!” no console.
A função main é uma função assíncrona com o atributo #[tokio::main]. Este atributo designa a função main como o ponto de entrada para o ambiente de execução Tokio. hello_world().await executa a função hello_world de forma assíncrona.
Atrasando Tarefas com Tokio
Uma tarefa comum na programação assíncrona é o uso de atrasos ou o agendamento de tarefas para serem executadas em um intervalo de tempo específico. O ambiente de execução Tokio fornece um mecanismo para usar temporizadores assíncronos e atrasos através do módulo tokio::time.
Veja como você pode atrasar uma operação com o ambiente de execução Tokio:
use std::time::Duration;
use tokio::time::sleep;
async fn delayed_operation() {
println!("Executando operação atrasada...");
sleep(Duration::from_secs(2)).await;
println!("Operação atrasada concluída.");
}
#[tokio::main]
async fn main() {
println!("Iniciando...");
delayed_operation().await;
println!("Finalizado.");
}
A função delayed_operation introduz um atraso de dois segundos com o método sleep. A função delayed_operation é assíncrona e, portanto, pode usar await para pausar sua execução até que o atraso seja concluído.
Tratamento de Erros em Programas Assíncronos
O tratamento de erros em código Rust assíncrono envolve o uso do tipo Result e o tratamento de erros Rust com o operador ?.
use tokio::fs::File;
use tokio::io;
use tokio::io::{AsyncReadExt};
async fn read_file_contents() -> io::Result<String> {
let mut file = File::open("file.txt").await?;
let mut contents = String::new();
file.read_to_string(&mut contents).await?;
Ok(contents)
}
async fn process_file() -> io::Result<()> {
let contents = read_file_contents().await?;
Ok(())
}
#[tokio::main]
async fn main() {
match process_file().await {
Ok(()) => println!("Arquivo processado com sucesso."),
Err(err) => eprintln!("Erro ao processar o arquivo: {}", err),
}
}
A função read_file_contents retorna um io::Result que representa a possibilidade de um erro de E/S. Usando o operador ? após cada operação assíncrona, o ambiente de execução Tokio irá propagar os erros na pilha de chamadas.
A função main trata o resultado com um match que imprime um texto com base no resultado da operação.
Reqwest Utiliza Programação Assíncrona para Operações HTTP
Muitas crates populares, incluindo Reqwest, usam Tokio para fornecer operações HTTP assíncronas.
Você pode usar Tokio com Reqwest para fazer múltiplas requisições HTTP sem bloquear outras tarefas. Tokio pode ajudar a gerenciar milhares de conexões simultâneas e recursos de forma eficiente.