Como trabalha com multithreading nos seus projetos…

No C++11 e versões superiores, uso <thread> para criar e gerir threads. Para sincronização, utilizo primitivas de <mutex>, <condition_variable> e <atomic>.

Abordagens principais:

std::thread: Criação e lançamento de novos threads.

#include <thread>
#include <iostream>

void worker_function() {
    std::cout << "Thread de trabalho iniciado\n";
    // ... algum trabalho ...
    std::cout << "Thread de trabalho terminado\n";
}

int main() {
    std::thread worker(worker_function);
    // ... trabalho principal ...
    worker.join(); // Esperar que o thread termine
    return 0;
}

std::mutex: Proteção de dados partilhados contra acesso concorrente.

#include <mutex>
#include <thread>
#include <vector>

std::mutex data_mutex;
std::vector<int> shared_data;

void add_to_data(int value) {
    std::lock_guard<std::mutex> lock(data_mutex); // bloqueio RAII
    shared_data.push_back(value);
}

// ... Threads chamando add_to_data ...

std::lock_guard e std::unique_lock: Envolventes RAII para mutexes, que garantem a libertação automática.
- std::lock_guard: Bloqueador simples, que não permite transferência de propriedade nem bloqueio diferido.
- std::unique_lock: Mais flexível, suporta bloqueio diferido, transferência de propriedade, bloqueio recursivo (com std::recursive_mutex).

std::condition_variable: Sinalização entre threads, permitindo que os threads esperem por uma condição específica.

#include <condition_variable>
#include <mutex>
#include <thread>
#include <queue>

std::queue<int> data_queue;
std::mutex queue_mutex;
std::condition_variable data_available;
bool stop_processing = false;

void producer() {
    // ... produzir dados ...
    {
        std::lock_guard<std::mutex> lock(queue_mutex);
        data_queue.push(/* dados */);
    }
    data_available.notify_one(); // Notificar um consumidor em espera
}

void consumer() {
    while (!stop_processing) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        data_available.wait(lock, []{ return !data_queue.empty() || stop_processing; });

        if (stop_processing && data_queue.empty()) {
            break;
        }

        int data = data_queue.front();
        data_queue.pop();
        lock.unlock(); // Desbloquear antes de processar os dados

        // ... processar dados ...
    }
}

// ... Threads executando produtor e consumidor ...

std::atomic: Para operações atômicas simples sem usar mutexes.

#include <atomic>
#include <thread>

std::atomic<int> counter(0);

void increment_counter() {
    counter++; // incremento atômico
}

// ... Threads chamando increment_counter ...

Pools de threads: Costumo usar o padrão de pool de threads para gerir recursos de threads e reduzir a sobrecarga de criação/eliminação. Implemento-os usando std::vector<std::thread>, filas de tarefas e primitivas de sincronização (std::mutex, std::condition_variable).

std::future e std::async: Para executar tarefas assíncronas e obter resultados.

#include <future>
#include <iostream>

int calculate_result(int input) {
    // ... cálculo complexo ...
    return input * 2;
}

int main() {
    std::future<int> future_result = std::async(std::launch::async, calculate_result, 10);
    // ... fazer outras tarefas ...
    int result = future_result.get(); // Esperar pelo resultado
    std::cout << "Resultado: " << result << std::endl;
    return 0;
}

Ao trabalhar com concorrência, dou especial atenção a:

Condições de corrida (Race conditions): Identificação e prevenção de situações onde o resultado depende da ordem não previsível de operações. Uso de mutexes, operações atômicas.
Deadlock (Interbloqueio): Análise de dependências entre bloqueios e aplicação de estratégias para evitá-los (por exemplo, ordem estrita na aquisição de mutexes).
Estados de vivacidade (Livelock, Starvation): Garantir uma distribuição "justa" do tempo de CPU e acesso a recursos.
Carga de trabalho nos threads: Distribuição uniforme do trabalho.
Depuração: Programas multithread são mais difíceis de depurar devido à imprevisibilidade na execução. Uso ferramentas especializadas e logging.

Para controle de baixo nível ou tarefas específicas, também posso usar POSIX Threads (pthread) em sistemas Unix ou a API Windows para multithreading. Em geral, tento seguir as ferramentas padrão do C++ por sua portabilidade.

Como trabalha com multithreading nos seus projetos?