在C++中使用多線程實現並行計算

在計算機科學領域，多線程並不是一個新的概念。多線程可以在單個程序中同時執行多個獨立的任務或操作，從而提高程序的執行效率。在C++中，多線程技術可以用於加速並行計算。本文將介紹如何在C++中使用多線程實現並行計算。

一、多線程基礎知識

在使用多線程技術之前，需要了解一些基本的多線程知識。

1. 線程是什麼？

線程是指在單個進程中執行的“子任務”，每個線程都擁有自己的程序計數器、堆棧和局部變量等。在多線程編程中，所有線程都共享程序的內存空間。因此，線程間通信和同步非常重要。

2. 如何創建線程？

在C++中，可以使用std::thread類創建並啟動一個線程。例如：

void my_thread_func(int arg){
    // 線程執行的代碼
}

int main(){
    std::thread th(my_thread_func, 42); // 創建線程並傳遞參數
    th.join(); // 等待線程執行結束
    return 0;
}

在這個例子中，我們創建了一個名為th的線程，並傳遞了參數42給my_thread_func函數。函數my_thread_func就是線程執行的代碼。

3. 如何同步多個線程？

在多線程編程中，同步非常重要。例如，如果多個線程同時訪問同一個共享資源，就需要使用互斥量（mutex）來避免數據競爭。互斥量是一種同步原語，可以在多個線程之間提供互斥。

在C++中，可以使用std::mutex類實現互斥量：

std::mutex mtx; // 全局互斥量

void my_thread_func(){
    mtx.lock(); // 加鎖
    // 訪問共享資源
    mtx.unlock(); // 解鎖
}

在這個例子中，我們定義了一個全局互斥量mtx，並在線程函數中使用lock和unlock成員函數來加鎖和解鎖互斥量。

二、使用多線程加速計算

在C++中，可以使用多線程技術加速計算。例如，在計算一個向量的模長時，可以使用多個線程同時計算不同部分的向量元素，然後把結果合併。

下面是一個使用多線程計算向量模長的示例：

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

std::mutex mtx; // 全局互斥量

double result = 0.0; // 全局變量，存儲計算結果

void calc_mag(const std::vector<double>& vec, int start, int end){
    double sum = 0.0;
    for(int i=start;i<end;i++){
        sum += vec[i]*vec[i];
    }
    mtx.lock(); // 加鎖
    result += sum;
    mtx.unlock(); // 解鎖
}

int main(){
    std::vector<double> vec{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};

    int num_threads = 4; // 線程數
    int step = vec.size() / num_threads;
    std::vector<std::thread> threads;
    for(int i=0;i<num_threads;i++){
        int start = i * step;
        int end = (i==num_threads-1) ? vec.size() : (i+1)*step;
        threads.emplace_back(calc_mag, std::ref(vec), start, end);
    }

    for(auto& th : threads){
        th.join();
    }

    result = std::sqrt(result);
    std::cout << "The magnitude of the vector is: " << result << std::endl;

    return 0;
}

在這個示例中，我們定義了一個全局變量result，並使用多個線程計算向量的平方和。每個線程負責計算向量的一部分，並把結果加到全局變量result中。在計算過程中使用互斥量mtx來避免數據競爭。最後，我們計算result的平方根，得到向量的模長。

需要注意的是，使用多線程並不總是會提高程序的執行效率。在上面的示例中，如果向量的長度比較小，使用多線程反而會降低程序的性能。

三、使用並行 STL 加速計算

在C++17標準中，引入了並行 STL，可以使用多線程並行化執行一些標準庫算法，從而加速計算。例如，可以使用std::transform_reduce算法計算向量的模長。

下面是一個使用並行STL計算向量模長的示例：

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>

int main(){
    std::vector<double> vec{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};

    double result = std::transform_reduce(
                        std::execution::par,
                        vec.begin(),
                        vec.end(),
                        0.0,
                        std::plus<>(),
                        [](double x){return x*x;}
                    );

    result = std::sqrt(result);
    std::cout << "The magnitude of the vector is: " << result << std::endl;

    return 0;
}

在這個示例中，我們使用std::transform_reduce算法計算向量的平方和，並使用std::sqrt函數計算平方根，得到向量的模長。使用std::transform_reduce算法時，第一個參數std::execution::par表示使用並行執行。

需要注意的是，並行STL並不是所有C++編譯器都支持的特性。如果編譯器不支持並行STL，可以使用OpenMP等工具庫來實現並行計算。