如何在Linux C++中實現線程池的優雅擴容與縮容

在 Linux 中，使用 C++ 實現線程池的優雅擴容與縮容可以通過以下幾個步驟來完成：

1. 定義線程池類 首先，我們需要定義一個線程池類，該類包含以下成員變量：

• 工作線程的數量
• 任務隊列
• 互斥鎖
• 條件變量
• 工作線程函數

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

class ThreadPool {
public:
    ThreadPool(size_t num_threads);
    ~ThreadPool();

    template<class F, class... Args>
    void enqueue(F&& f, Args&&... args);

private:
    size_t num_threads_;
    std::vector<std::thread> threads_;
    std::queue<std::function<void()>> tasks_;
    std::mutex mutex_;
    std::condition_variable cond_;

    void worker_thread();
};

2. 實現線程池構造函數和析構函數 在構造函數中，我們創建指定數量的工作線程。在析構函數中，我們等待所有工作線程完成并關閉它們。

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

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

3. 實現任務入隊函數 enqueue 函數用于將任務添加到任務隊列中。

template<class F, class... Args>
void ThreadPool::enqueue(F&& f, Args&&... args) {
    {
        std::unique_lock<std::mutex> lock(mutex_);
        tasks_.emplace([f, args...] { f(args...); });
    }
    cond_.notify_one();
}

4. 實現工作線程函數 worker_thread 函數是每個工作線程執行的函數。它從任務隊列中獲取任務并執行。

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

5. 實現優雅擴容與縮容 為了實現優雅擴容與縮容，我們可以在運行時根據需要增加或減少工作線程的數量。以下是一個簡單的示例：

void ThreadPool::resize(size_t new_num_threads) {
    if (new_num_threads == num_threads_) {
        return;
    }

    // 停止舊的工作線程
    {
        std::unique_lock<std::mutex> lock(mutex_);
        stop_ = true;
    }
    cond_.notify_all();
    for (auto& thread : threads_) {
        if (thread.joinable()) {
            thread.join();
        }
    }

    // 更新工作線程數量
    num_threads_ = new_num_threads;

    // 啟動新的工作線程
    for (size_t i = 0; i < new_num_threads; ++i) {
        threads_.emplace_back(&ThreadPool::worker_thread, this);
    }
}

現在，你可以使用 resize 函數來優雅地擴展或縮小線程池的大小。請注意，這只是一個簡單的示例，實際應用中可能需要考慮更多的因素，例如線程池的初始化、銷毀和同步等。