线程池

合集 - c++(12)

1.makefile模版2024-09-042.使用Cmake-编写CMakeLists.txt 文件，vscode2024-09-043.断言assert，异常，类型转换2024-09-054.c++多线程，锁2024-09-235.线程同步：锁，条件变量，并发2024-09-236.多线程问题：异常处理，单例，双重检查锁定2024-09-237.boost.asio 异步网络编程2024-09-25

8.线程池2024-09-25

9.忙等，yield()，死循环，原子atomic2024-09-2910.基本类型大小，类大小及内存对齐2024-09-3011.快速排序算法及多线程试验2024-10-0112.单例2024-10-21

收起

1）线程池 PoolThread
线程池可以避免在处理短时间任务时创建与销毁线程的代价，它维护着多个线程，等待着监督管理者分配可并发执行的任务，从而提高了整体性能

2）单例类

static ThreadPool& instance() {
  //局部静态变量，单例类只构造一次
        static ThreadPool ins;
        return ins;
    }

3）线程池逻辑

构造单例，start函数启动线程池
初始化n个线程，每个线程中等待队列产生任务（条件变量）
任务到来，线程被唤醒，移动任务对象（std::package_task）到线程中；
线程总数-1
执行task

commit：提交任务到线程池
绑定任务到task,使用task.getfuture()获取返回值
将task加入队列
唤醒某个线程

4）线程池的实现

#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__

#include <atomic>
#include <condition_variable>
#include <future>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>

class ThreadPool  {
public:
    ThreadPool(const ThreadPool&) = delete;
    ThreadPool&        operator=(const ThreadPool&) = delete;

    static ThreadPool& instance() {
        static ThreadPool ins;
        return ins;
    }

    using Task = std::packaged_task<void()>;


    ~ThreadPool() {
        stop();
    }

    template <class F, class... Args>
    auto commit(F&& f, Args&&... args) -> std::future<decltype(f(args...))> {
        using RetType = decltype(f(args...));
        if (stop_.load())
            return std::future<RetType>{};

        auto task = std::make_shared<std::packaged_task<RetType()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...));

        std::future<RetType> ret = task->get_future();
        {
            std::lock_guard<std::mutex> cv_mt(cv_mt_);
            tasks_.emplace([task] { (*task)(); });
        }
        cv_lock_.notify_one();
        return ret;
    }

    int idleThreadCount() {
        return thread_num_;
    }

private:
    ThreadPool(unsigned int num = 5)
        : stop_(false) {
            {
                if (num < 1)
                    thread_num_ = 1;
                else
                    thread_num_ = num;
            }
            start();
    }
    void start() {
        for (int i = 0; i < thread_num_; ++i) {
            pool_.emplace_back([this]() {
                while (!this->stop_.load()) {
                    Task task;
                    {
                        std::unique_lock<std::mutex> cv_mt(cv_mt_);
                        this->cv_lock_.wait(cv_mt, [this] {
                            return this->stop_.load() || !this->tasks_.empty();
                        });
                        if (this->tasks_.empty())
                            return;

                        task = std::move(this->tasks_.front());
                        this->tasks_.pop();
                    }
                    this->thread_num_--;
                    task();
                    this->thread_num_++;
                }
            });
        }
    }
    void stop() {
        stop_.store(true);
        cv_lock_.notify_all();
        for (auto& td : pool_) {
            if (td.joinable()) {
                std::cout << "join thread " << td.get_id() << std::endl;
                td.join();
            }
        }
    }

private:
    std::mutex               cv_mt_;
    std::condition_variable  cv_lock_;
    std::atomic_bool         stop_;
    std::atomic_int          thread_num_;
    std::queue<Task>         tasks_;
    std::vector<std::thread> pool_;
};

#endif  // !__THREAD_POOL_H__