Programação Assíncrona em C++: Guia Completo para Iniciantes

Introdução à programação assíncrona em C++

Aplicações modernas exigem cada vez mais alto desempenho e capacidade de resposta. A programação assíncrona em C++ é uma ferramenta poderosa que permite executar várias tarefas simultaneamente sem bloquear o fluxo principal de execução. Neste guia, abordaremos os fundamentos da assincronia em C++: desde abordagens clássicas até as coroutines modernas, adicionadas ao padrão C++20.

Se você é iniciante em C++, mas já conhece a sintaxe básica, este artigo ajudará você a entender como fazer seu programa realizar várias coisas ao mesmo tempo. Veremos exemplos práticos que podem ser aplicados imediatamente em seus projetos.

Conceitos principais e por que isso é necessário

Na programação síncrona tradicional, o código é executado estritamente de forma sequencial: uma operação termina, então a próxima começa. Isso é simples, mas ineficiente se o programa estiver aguardando entrada/saída (leitura de arquivo, requisição de rede) ou realizando cálculos pesados.

A programação assíncrona resolve esse problema, permitindo:

• Não bloquear o fluxo principal — a interface do aplicativo permanece responsiva.
• Acelerar a execução — processamento paralelo de dados em processadores multi-core.
• Usar recursos de forma eficiente — enquanto uma tarefa espera por dados, outra pode ser executada.

Em C++, existem várias maneiras de implementar assincronia: desde threads de baixo nível (std::thread) até abstrações de alto nível (std::async, std::future e coroutines).

1. Assincronia com std::async e std::future

A maneira mais simples de iniciar uma tarefa assíncrona em C++ é usar a função std::async do arquivo de cabeçalho <future>. Ela retorna um objeto std::future, que armazena o resultado da execução.

Exemplo básico

#include <iostream>#include <future>#include <thread>#include <chrono>

// Função que será executada assincronamenteint slow_calculation(int x) {    std::this_thread::sleep_for(std::chrono::seconds(2)); // Simula trabalho demorado    return x * x;}

int main() {    std::cout << "Iniciando tarefa assíncrona..." << std::endl;        // Inicia slow_calculation em uma thread separada    std::future<int> result = std::async(std::launch::async, slow_calculation, 5);        std::cout << "Thread principal continua trabalhando..." << std::endl;        // Obtém o resultado (bloqueia a thread se a tarefa ainda não foi concluída)    int value = result.get();    std::cout << "Resultado: " << value << std::endl; // Saída: 25        return 0;}

Neste exemplo, std::async inicia a função em uma thread separada. Enquanto ela é executada, a thread principal exibe uma mensagem. O método get() aguarda a conclusão da tarefa e retorna o resultado.

Políticas de inicialização

std::async tem dois modos:

• std::launch::async — a tarefa é garantidamente executada em uma nova thread.
• std::launch::deferred — a tarefa é executada de forma lazy, apenas quando get() ou wait() é chamado na mesma thread.

2. Promises e Futures: gerenciamento manual

Se você precisa de um controle mais flexível sobre tarefas assíncronas, use o par std::promise e std::future. O promise permite definir um valor ou exceção em uma thread, e o future permite obtê-lo em outra.

Exemplo com promise

#include <iostream>#include <future>#include <thread>

void worker(std::promise<int> prom, int a, int b) {    try {        int result = a / b; // Pode
```