如何在Linux C++中編寫可重用的多線程組件

在 Linux 中使用 C++ 編寫可重用的多線程組件需要遵循以下步驟：

1. 包含頭文件： 首先，確保包含了必要的頭文件。對于多線程編程，你需要包含 <iostream>、<thread>、<mutex> 和 <vector>。

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

2. 定義互斥鎖： 為了確保多線程組件中的數據在任何時候只被一個線程訪問，需要使用互斥鎖（std::mutex）。定義一個全局互斥鎖對象，以便在多個線程之間共享。

std::mutex mtx;

3. 創建可重用的多線程函數： 編寫一個封裝了多線程邏輯的函數。這個函數將接受一個任務列表作為參數，并在單獨的線程中執行每個任務。

void execute_tasks(const std::vector<std::function<void()>>& tasks) {
    for (const auto& task : tasks) {
        std::unique_lock<std::mutex> lock(mtx);
        task();
        lock.unlock();
    }
}

4. 創建線程池： 為了實現可重用的多線程組件，可以創建一個線程池類。這個類將負責管理線程的創建和銷毀，以及任務的分配和執行。

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

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }

    template <typename F, typename... Args>
    void enqueue(F&& task, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(mtx);
            tasks.emplace_back(std::bind(std::forward<F>(task), std::forward<Args>(args)...));
        }
        cv.notify_one();
    }

private:
    void worker_thread() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(mtx);
                cv.wait(lock, [this] { return stop || !tasks.empty(); });
                if (stop && tasks.empty()) {
                    return;
                }
                task = std::move(tasks.front());
                tasks.erase(tasks.begin());
            }
            task();
        }
    }

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

5. 使用線程池： 現在可以在程序中使用線程池來執行多個任務。首先創建一個線程池實例，然后將要執行的任務添加到線程池中。

int main() {
    ThreadPool pool(4);

    std::vector<std::function<void()>> tasks = {
        [] { std::cout << "Task 1 is running in thread " << std::this_thread::get_id() << std::endl; },
        [] { std::cout << "Task 2 is running in thread " << std::this_thread::get_id() << std::endl; },
        [] { std::cout << "Task 3 is running in thread " << std::this_thread::get_id() << std::endl; },
    };

    for (const auto& task : tasks) {
        pool.enqueue(task);
    }

    return 0;
}

這個例子展示了如何在 Linux 中使用 C++ 編寫可重用的多線程組件。你可以根據需要擴展這個類，以支持更多的功能和配置選項。