C++线程池库如何支持动态扩容

要让C++线程池库支持动态扩容，你需要实现以下功能：

1. 在线程池类中维护一个线程数量的变量，例如num_threads。
2. 提供一个方法（例如resize(size_t new_size)），用于改变线程池的大小。这个方法应该接受一个参数，表示新的线程池大小。
3. 在resize方法中，根据新的线程池大小与当前线程池大小的关系，来决定是创建新的线程还是销毁现有线程。
4. 如果需要创建新的线程，可以使用std::thread创建线程并将其添加到线程池中。
5. 如果需要销毁现有线程，可以通过向线程发送一个特殊的任务（例如一个空任务）来通知线程退出，然后等待线程结束并将其从线程池中移除。

以下是一个简单的C++线程池库示例，支持动态扩容：

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

class ThreadPool {
public:
    ThreadPool(size_t num_threads) : num_threads_(num_threads), running_(true) {
        resize(num_threads);
    }

    ~ThreadPool() {
        stop();
    }

    void resize(size_t new_size) {
        std::unique_lock<std::mutex> lock(mutex_);
        if (new_size > num_threads_) {
            // 创建新的线程
            for (size_t i = num_threads_; i < new_size; ++i) {
                threads_.emplace_back(&ThreadPool::worker, this);
            }
        } else if (new_size < num_threads_) {
            // 销毁现有线程
            for (size_t i = new_size; i < num_threads_; ++i) {
                tasks_.push([]() {}); // 添加空任务以通知线程退出
            }
        }
        num_threads_ = new_size;
    }

    void add_task(const std::function<void()>& task) {
        std::unique_lock<std::mutex> lock(mutex_);
        tasks_.push(task);
        cv_.notify_one();
    }

private:
    void worker() {
        while (running_) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(mutex_);
                cv_.wait(lock, [this]() { return !tasks_.empty() || !running_; });
                if (!running_) {
                    break;
                }
                task = std::move(tasks_.front());
                tasks_.pop();
            }
            task(); // 执行任务
        }
    }

    void stop() {
        {
            std::unique_lock<std::mutex> lock(mutex_);
            running_ = false;
        }
        cv_.notify_all(); // 唤醒所有线程以便它们可以退出
        for (auto& thread : threads_) {
            thread.join();
        }
    }

    size_t num_threads_;
    bool running_;
    std::vector<std::thread> threads_;
    std::queue<std::function<void()>> tasks_;
    std::mutex mutex_;
    std::condition_variable cv_;
};

这个示例中的ThreadPool类包含了一个resize方法，可以用于动态调整线程池的大小。当线程池大小减小时，会向线程池中的线程发送空任务以通知它们退出。当线程池大小增加时，会创建新的线程并将其添加到线程池中。