C++中如何实现自定义线程池库

在C++中，可以使用C++11标准中的线程和互斥锁等特性来实现一个简单的线程池库。以下是一个基本的线程池实现：

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


class ThreadPool {

public:
    ThreadPool(size_t num_threads) {
    
        for (size_t i = 0;
     i <
     num_threads;
 ++i) {

            workers.emplace_back([this]() {

                while (true) {
    
                    std::function<
    void()>
     task;

                    {
    
                        std::unique_lock<
    std::mutex>
     lock(queue_mutex);

                        condition.wait(lock, [this]() {
     return !tasks.empty() || stop;
 }
    );
    
                        if (stop &
    &
 tasks.empty()) {
    
                            return;

                        }
    
                        task = std::move(tasks.front());
    
                        tasks.pop();

                    }
    
                    task();

                }

            }
    );

        }

    }


    ~ThreadPool() {

        {
    
            std::unique_lock<
    std::mutex>
     lock(queue_mutex);
    
            stop = true;

        }
    
        condition.notify_all();
    
        for (auto&
 worker : workers) {
    
            worker.join();

        }

    }
    

    template<
    typename F, typename... Args>
    
    void enqueue(F&
    &
     f, Args&
    &
... args) {
    
        auto task = std::make_shared<
    std::packaged_task<
    void()>
    >
    (
            std::bind(std::forward<
    F>
    (f), std::forward<
    Args>
    (args)...));

        {
    
            std::unique_lock<
    std::mutex>
     lock(queue_mutex);

            tasks.push([task]() {
     (*task)();
 }
    );

        }
    
        condition.notify_one();

    }
    

private:
    std::vector<
    std::thread>
     workers;
    
    std::queue<
    std::function<
    void()>
    >
     tasks;
    
    std::mutex queue_mutex;
    
    std::condition_variable condition;
    
    bool stop = false;

}
    ;
    

这个线程池实现包含以下几个部分：

1. ThreadPool类定义了线程池的基本结构，包括工作线程、任务队列、互斥锁和条件变量。
2. 构造函数ThreadPool(size_t num_threads)初始化了指定数量的工作线程，并启动它们。每个工作线程在一个无限循环中等待任务队列中的任务。
3. 析构函数~ThreadPool()设置停止标志，唤醒所有工作线程，并等待它们完成任务并退出。
4. enqueue函数模板用于将任务添加到任务队列中。它接受一个可调用对象（如函数、lambda表达式等）以及该对象的参数。任务被打包为一个std::packaged_task对象，然后添加到任务队列中。

使用示例：

#include<
    iostream>
    
#include<
    chrono>
    
#include<
    thread>


void task(int n) {
    
    std::this_thread::sleep_for(std::chrono::seconds(n));
    
    std::cout <
    <
     "Task " <
    <
     n <
    <
     " completed"<
    <
     std::endl;

}


int main() {
    
    ThreadPool pool(4);
    

    for (int i = 1;
     i <
    = 8;
 ++i) {
    
        pool.enqueue(task, i);

    }
    

    std::this_thread::sleep_for(std::chrono::seconds(10));
    
    return 0;

}
    

这个示例创建了一个包含4个工作线程的线程池，并向其提交了8个任务。每个任务都会休眠一段时间，然后输出一条消息。主线程在所有任务完成后休眠10秒，然后退出。

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