如何在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 函数来优雅地扩展或缩小线程池的大小。请注意，这只是一个简单的示例，实际应用中可能需要考虑更多的因素，例如线程池的初始化、销毁和同步等。