Ako pracujete s viacvláknovým spracovaním vo svojich…

V C++11 a vyšších verziách používam <thread> na vytváranie a správu vlákien. Na synchronizáciu používam primitívy z <mutex>, <condition_variable> a <atomic>.

Hlavné prístupy:

std::thread: Vytváranie a spúšťanie nových vlákien.

#include <thread>
#include <iostream>

void worker_function() {
    std::cout << "Začiatok vlákna pracovníka\n";
    // ... nejaká práca ...
    std::cout << "Koniec vlákna pracovníka\n";
}

int main() {
    std::thread worker(worker_function);
    // ... práca v hlavnom vlákne ...
    worker.join(); // Čakanie na ukončenie vlákna
    return 0;
}

std::mutex: Ochrana zdieľaných dát pred súčasným prístupom.

#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); // RAII zámok
    shared_data.push_back(value);
}

// ... vlákna volajúce add_to_data ...

std::lock_guard a std::unique_lock: RAII obalové objekty pre mutexy, zabezpečujúce automatické uvoľnenie zámku.
- std::lock_guard: Jednoduchý blokovač, ktorý neumožňuje prenos vlastníctva alebo odložené zamknutie.
- std::unique_lock: Flexibilnejší, podporuje odložené zamknutie, prenos vlastníctva, rekurzívne zamknutie (pri použití s std::recursive_mutex).

std::condition_variable: Signál medzi vláknami, umožňujúci vláknam čakať na určitý stav.

#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() {
    // ... produkcia dát ...
    {
        std::lock_guard<std::mutex> lock(queue_mutex);
        data_queue.push(/* dáta */);
    }
    data_available.notify_one(); // Oznámenie čakajúcemu spotrebiteľovi
}

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(); // Uvoľnenie pred spracovaním dát

        // ... spracovanie dát ...
    }
}

// ... vlákna bežiace ako producent a spotrebiteľ ...

std::atomic: Pre jednoduché atomárne operácie bez použitia mutexov.

#include <atomic>
#include <thread>

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

void increment_counter() {
    counter++; // Atomárne zvýšenie
}

// ... vlákna volajúce increment_counter ...

Pooly vlákien: Často používam vzor poolu vlákien na správu zdrojov vlákien a zníženie nákladov na ich vytváranie a ničenie.

std::future a std::async: Na vykonávanie asynchrónnych úloh a získavanie výsledkov.

#include <future>
#include <iostream>

int calculate_result(int input) {
    // ... zložité výpočty ...
    return input * 2;
}

int main() {
    std::future<int> future_result = std::async(std::launch::async, calculate_result, 10);
    // ... iné práce ...
    int result = future_result.get(); // Čakanie na výsledok
    std::cout << "Výsledok: " << result << std::endl;
    return 0;
}

Pri práci s viacvláknovým programovaním venujem osobitnú pozornosť nasledujúcim témam:

Stav závodu (Race conditions): Identifikácia a prevencia situácií, keď výsledok závisí od nepredvídateľného poradia vykonávania operácií.
Zablokovanie (Deadlock): Analýza závislostí medzi zámkami a použitie stratégií na ich vyhýbanie.
Stavy aktivity (Livelock, Starvation): Zabezpečenie "spravodlivého" rozdelenia procesorového času a prístupu k zdrojom.
Zaťaženie vlákien: Rovnomerné rozdelenie práce medzi vlákna.
Ladenie: Viacvláknové programy sú ťažšie na ladenie kvôli nepredvídateľnosti vykonávania.

V prípade potreby môžem použiť POSIX Threads (pthread) v Unixových systémoch alebo Windows API pre viacvláknové programovanie. Vo všeobecnosti sa snažím používať štandardné nástroje C++ kvôli ich prenosnosti.

Ako pracujete s viacvláknovým spracovaním vo svojich projektoch?