Linux C++多線程編程的線程池設計思路

設計一個線程池在Linux環境下使用C++進行多線程編程是一個常見的任務。線程池可以幫助你有效地管理線程，避免頻繁地創建和銷毀線程帶來的開銷，同時提高系統的響應性和資源利用率。以下是一個基本的線程池設計思路：

1. 定義線程池類

首先，定義一個線程池類，包含以下主要成員變量：

• max_threads: 最大線程數
• min_threads: 最小線程數
• current_threads: 當前活躍線程數
• work_queue: 任務隊列
• threads: 存儲線程的容器
• condition_var: 用于線程同步的條件變量
• mutex: 用于保護共享資源的互斥鎖

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

class ThreadPool {
public:
    ThreadPool(size_t min_threads, size_t max_threads);
    ~ThreadPool();

    template<typename F, typename... Args>
    std::future<typename std::result_of<F(Args...)>::type> enqueue(F&& f, Args&&... args);

private:
    void worker_thread();
    void wait_for_available_threads();
    void adjust_thread_count();

    size_t max_threads_;
    size_t min_threads_;
    size_t current_threads_;
    std::queue<std::packaged_task<void()>> work_queue_;
    std::vector<std::thread> threads_;
    std::mutex mutex_;
    std::condition_variable condition_var_;
};

2. 構造函數和析構函數

構造函數初始化線程池，設置最小和最大線程數。析構函數確保所有線程在對象銷毀時正確退出。

ThreadPool::ThreadPool(size_t min_threads, size_t max_threads)
    : max_threads_(max_threads), min_threads_(min_threads), current_threads_(0) {
    for (size_t i = 0; i < min_threads; ++i) {
        worker_thread();
    }
}

ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(mutex_);
        stop_ = true;
    }
    condition_var_.notify_all();
    for (auto& thread : threads_) {
        if (thread.joinable()) {
            thread.join();
        }
    }
}

3. 工作線程函數

每個工作線程運行worker_thread函數，從任務隊列中取出任務并執行。

void ThreadPool::worker_thread() {
    while (true) {
        std::packaged_task<void()> task;
        {
            std::unique_lock<std::mutex> lock(mutex_);
            condition_var_.wait(lock, [this] { return stop_ || !work_queue_.empty(); });
            if (stop_ && work_queue_.empty()) {
                break;
            }
            task = std::move(work_queue_.front());
            work_queue_.pop();
        }
        task();
        adjust_thread_count();
    }
}

4. 調整線程數

adjust_thread_count函數根據當前活躍線程數和任務隊列的狀態調整線程數。

void ThreadPool::adjust_thread_count() {
    size_t available_threads = max_threads_ - current_threads_;
    while (available_threads > 0 && !work_queue_.empty()) {
        worker_thread();
        --available_threads;
    }
    while (current_threads_ < min_threads_ && !work_queue_.empty()) {
        worker_thread();
        ++current_threads_;
    }
}

5. 入隊任務

enqueue函數將任務添加到任務隊列中，并通知一個等待的線程來執行該任務。

template<typename F, typename... Args>
std::future<typename std::result_of<F(Args...)>::type> ThreadPool::enqueue(F&& f, Args&&... args) {
    using return_type = typename std::result_of<F(Args...)>::type;
    auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    std::future<return_type> result = task->get_future();
    {
        std::unique_lock<std::mutex> lock(mutex_);
        if (stop_) {
            throw std::runtime_error("enqueue on stopped ThreadPool");
        }
        work_queue_.push(*task);
    }
    condition_var_.notify_one();
    return result;
}

6. 使用示例

以下是一個簡單的使用示例，展示了如何創建一個線程池并提交任務。

#include <iostream>
#include <future>

void task(int id) {
    std::cout << "Task " << id << " started" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Task " << id << " finished" << std::endl;
}

int main() {
    ThreadPool pool(2, 5);

    std::vector<std::future<void>> results;
    for (int i = 0; i < 10; ++i) {
        results.push_back(pool.enqueue(task, i));
    }

    for (auto& result : results) {
        result.wait();
    }

    return 0;
}

這個示例創建了一個包含2個最小線程和5個最大線程的線程池，并提交了10個任務。線程池會自動管理線程的創建和銷毀，確保任務能夠高效地執行。