[C++] Tworzenie aplikacji wielowątkowych

Współbieżność jest jednym z kluczowych aspektów programowania wielowątkowego, który pozwala na równoczesne wykonywanie różnych zadań w aplikacji. W języku C++ istnieje wiele narzędzi i mechanizmów, które umożliwiają tworzenie wielowątkowych aplikacji. W tym artykule skupię się na omówieniu kilku popularnych narzędzi współbieżności w C++ oraz przedstawię praktyczny przykład ich użycia.

Wątki

Język C++ oferuje wbudowane wsparcie dla tworzenia i zarządzania wątkami przy użyciu biblioteki standardowej. Wątki umożliwiają równoczesne wykonywanie różnych fragmentów kodu i mogą być używane do zrównoleglenia obliczeń oraz asynchronicznego wykonania operacji.

Mutexy

Mutexy są mechanizmem synchronizacji, który zapewnia, że tylko jeden wątek może mieć dostęp do chronionego przez mutex kodu w danym czasie. Dzięki nim można zapewnić bezpieczny dostęp do współdzielonych zasobów i uniknąć wyścigów (race conditions).

Zmienne warunkowe

Zmienne warunkowe umożliwiają wstrzymywanie wątków i ich wznowienie na podstawie określonych warunków. Są one przydatne, gdy wątek musi czekać na spełnienie pewnych warunków przed kontynuacją działania.

Przykład użycia

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

std::mutex mtx;

void sumVectors(const std::vector<int>& vec1, const std::vector<int>& vec2, int& result)
{
    int sum = 0;
    for (int i = 0; i < vec1.size(); ++i)
    {
        sum += vec1[i] + vec2[i];
    }
    
    std::lock_guard<std::mutex> lock(mtx);
    result += sum;
}

int main()
{
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    std::vector<int> vec2 = {6, 7, 8, 9, 10};
    int result = 0;
    
    std::thread t1(sumVectors, std::ref(vec1), std::ref(vec2), std::ref(result));
    std::thread t2(sumVectors, std::ref(vec1), std::ref(vec2), std::ref(result));
    
    t1.join();
    t2.join();
    
    std::cout << "Sum: " << result << std::endl;
    
    return 0;
}

W powyższym przykładzie używamy dwóch wątków, które równolegle sumują elementy z dwóch wektorów. W celu uniknięcia wyścigów zostaje użyty mutex, aby synchronizować dostęp do zmiennej wynikowej. Mutex zapewnia, że tylko jeden wątek ma dostęp do zmiennej wynikowej w danym czasie.

Współbieżność jest ważnym aspektem programowania wielowątkowego, który pozwala na efektywne wykorzystanie zasobów i zrównoleglenie operacji. W powyższym przykładzie pokazano, jak można zastosować narzędzia współbieżności do równoległego obliczania sumy liczb z dwóch wektorów.