Linux C++如何進行并發編程

在Linux環境下使用C++進行并發編程，主要有以下幾種方式：

1. POSIX Threads (pthreads)

POSIX Threads是Linux下最常用的線程庫。

基本步驟：

1. 包含頭文件：#include <pthread.h>
2. 定義線程函數：void* thread_function(void* arg);
3. 創建線程：pthread_t thread_id; pthread_create(&thread_id, NULL, thread_function, (void*)arg);
4. 等待線程結束：pthread_join(thread_id, NULL);

示例代碼：

#include <iostream>
#include <pthread.h>

void* thread_function(void* arg) {
    std::cout << "Thread is running" << std::endl;
    return NULL;
}

int main() {
    pthread_t thread_id;
    if (pthread_create(&thread_id, NULL, thread_function, NULL) != 0) {
        std::cerr << "Failed to create thread" << std::endl;
        return 1;
    }
    pthread_join(thread_id, NULL);
    std::cout << "Thread has finished" << std::endl;
    return 0;
}

2. C++11 Standard Library Threads

C++11引入了標準庫線程支持，使用起來更加方便和安全。

基本步驟：

1. 包含頭文件：#include <thread>
2. 定義線程函數：void thread_function();
3. 創建線程：std::thread t(thread_function);
4. 等待線程結束：t.join();

示例代碼：

#include <iostream>
#include <thread>

void thread_function() {
    std::cout << "Thread is running" << std::endl;
}

int main() {
    std::thread t(thread_function);
    t.join();
    std::cout << "Thread has finished" << std::endl;
    return 0;
}

3. C++11 Future and Promise

Future和Promise提供了一種更高級的并發編程方式，用于線程間的同步和數據傳遞。

基本步驟：

1. 包含頭文件：#include <future>
2. 創建Promise對象：std::promise<T> prom;
3. 獲取Future對象：std::future<T> fut = prom.get_future();
4. 在線程中設置值：prom.set_value(value);
5. 在主線程中獲取值：T result = fut.get();

示例代碼：

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

void thread_function(std::promise<int> prom) {
    int value = 42;
    prom.set_value(value);
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread t(thread_function, std::move(prom));
    t.join();
    int result = fut.get();
    std::cout << "Thread returned: " << result << std::endl;
    return 0;
}

4. C++17 Parallel Algorithms

C++17引入了并行算法庫，可以方便地對標準庫容器進行并行操作。

基本步驟：

1. 包含頭文件：#include <execution>
2. 使用并行算法：std::for_each(std::execution::par, container.begin(), container.end(), [](auto& elem) { /* operation */ });

示例代碼：

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::for_each(std::execution::par, vec.begin(), vec.end(), [](int& elem) {
        elem *= 2;
    });
    for (int elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
    return 0;
}

總結

• POSIX Threads：適用于需要底層控制的場景。
• C++11 Standard Library Threads：提供了更現代和安全的線程管理。
• Future and Promise：適用于復雜的線程間通信和同步。
• Parallel Algorithms：適用于對標準庫容器進行并行操作。

選擇哪種方式取決于具體的需求和項目的復雜性。