如何在Linux C++中管理高并發的多線程

在 Linux 中使用 C++ 管理高并發的多線程，你可以使用以下方法和庫：

1. 使用 POSIX 線程（pthread）庫

POSIX 線程庫是 Linux 下最常用的線程編程庫。要使用 pthread，首先需要包含頭文件 pthread.h。創建線程、設置線程屬性、線程同步和結束線程等操作都有對應的函數。

示例代碼：

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

void* print_hello(void* thread_id) {
    std::cout << "Hello from thread " << *(int*)thread_id << std::endl;
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[5];
    int thread_ids[5];

    for (int i = 0; i < 5; ++i) {
        thread_ids[i] = i;
        if (pthread_create(&threads[i], NULL, print_hello, (void*)&thread_ids[i]) != 0) {
            std::cerr << "Error creating thread "<< i << std::endl;
            return 1;
        }
    }

    for (int i = 0; i < 5; ++i) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

2. 使用 C++11 標準庫中的線程支持

C++11 引入了 <thread> 庫，使得多線程編程更加簡便。使用 std::thread 類可以輕松地創建和管理線程。

示例代碼：

#include <iostream>
#include <thread>

void print_hello(int thread_id) {
    std::cout << "Hello from thread " << thread_id << std::endl;
}

int main() {
    std::thread threads[5];

    for (int i = 0; i < 5; ++i) {
        threads[i] = std::thread(print_hello, i);
    }

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

    return 0;
}

3. 使用線程池

線程池是一種管理線程的高級技術，它可以復用已創建的線程，減少線程創建和銷毀的開銷。在 Linux 中，可以使用第三方庫，如 ThreadPool 或 libevent。

示例代碼（使用 ThreadPool 庫）：

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "ThreadPool.h"

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back(&ThreadPool::work, this);
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

    template<class F, class... Args>
    void enqueue(F&& f, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace([f, args...] { f(args...); });
        }
        condition.notify_one();
    }

private:
    void work() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this] { return stop || !tasks.empty(); });
                if (stop && tasks.empty()) {
                    return;
                }
                task = std::move(tasks.front());
                tasks.pop();
            }
            task();
        }
    }

    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
};

void print_hello(int thread_id) {
    std::cout << "Hello from thread " << thread_id << std::endl;
}

int main() {
    ThreadPool pool(5);

    for (int i = 0; i < 5; ++i) {
        pool.enqueue(print_hello, i);
    }

    return 0;
}

注意：在使用多線程時，需要考慮線程同步和互斥的問題，以避免數據競爭和不一致。可以使用互斥鎖（std::mutex）、條件變量（std::condition_variable）等工具來實現線程同步。