C++中如何實現自定義線程池庫

在C++中，可以使用C++11標準中的線程和互斥鎖等特性來實現一個簡單的線程池庫。以下是一個基本的線程池實現：

#include<iostream>
#include<vector>
#include<queue>
#include<thread>
#include <mutex>
#include<condition_variable>
#include<functional>

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this]() {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this]() { return !tasks.empty() || stop; });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

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

    template<typename F, typename... Args>
    void enqueue(F&& f, Args&&... args) {
        auto task = std::make_shared<std::packaged_task<void()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.push([task]() { (*task)(); });
        }
        condition.notify_one();
    }

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

這個線程池實現包含以下幾個部分：

1. ThreadPool類定義了線程池的基本結構，包括工作線程、任務隊列、互斥鎖和條件變量。
2. 構造函數ThreadPool(size_t num_threads)初始化了指定數量的工作線程，并啟動它們。每個工作線程在一個無限循環中等待任務隊列中的任務。
3. 析構函數~ThreadPool()設置停止標志，喚醒所有工作線程，并等待它們完成任務并退出。
4. enqueue函數模板用于將任務添加到任務隊列中。它接受一個可調用對象（如函數、lambda表達式等）以及該對象的參數。任務被打包為一個std::packaged_task對象，然后添加到任務隊列中。

使用示例：

#include<iostream>
#include<chrono>
#include<thread>

void task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "Task " << n << " completed"<< std::endl;
}

int main() {
    ThreadPool pool(4);

    for (int i = 1; i <= 8; ++i) {
        pool.enqueue(task, i);
    }

    std::this_thread::sleep_for(std::chrono::seconds(10));
    return 0;
}

這個示例創建了一個包含4個工作線程的線程池，并向其提交了8個任務。每個任務都會休眠一段時間，然后輸出一條消息。主線程在所有任務完成后休眠10秒，然后退出。