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方法，可以用于动态调整线程池的大小。当线程池大小减小时，会向线程池中的线程发送空任务以通知它们退出。当线程池大小增加时，会创建新的线程并将其添加到线程池中。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！