C++11缓存式线程池

置顶吴盐煮_

于 2024-08-14 21:34:17 发布

阅读量582

点赞数 12

文章标签：缓存开发语言 c++

本文链接：https://blog.csdn.net/m0_68224121/article/details/141199355

版权

一、概述

动态调整线程数量：与固定式线程池不同，缓存式线程池的线程数量是动态调整的。当有新任务提交时，如果线程池中有空闲的线程，则会立即使用空闲线程执行任务；如果线程池中没有空闲线程，则会创建一个新的线程来执行任务。当线程空闲一段时间后，超过线程最大空闲时间（默认为60s），线程将会被回收和销毁。

二、同步队列的设计

对于缓存式线程池同步队列的设计，首先会在类中设置容器来存放任务（list），另外使用mutex来实现生产者和消费者的互斥关系，以及两个条件变量（生产者条件变量m_notFull，消费者条件变量m_notEmpty）来唤醒两者。需要设计m_waitTime来限制任务队列满等待时间，以及m_maxSize来限制任务队列最大任务数量，防止任务数过多撑满内存。最后，需要一个布尔类型变量m_needStop来设置同步队列启动与否。

在设置生产者和消费者模型时(Add和Take），需要设置条件变量的等待时间，当到达m_waitTime，说明出现超时，此时便可以直接退出，防止线程长期占用CPU；在停止同步队列时，即Stop（），首先需要进行加锁，不能让生产者和消费者此时再去获取锁，设置关闭同步队列标志m_needStop，唤醒生产者和消费者，此时生产者和消费者就会退出。

三、缓存式线程池的设计

对于缓存式线程池的设计，需要设置变量KeepAliveTime线程最大存活时间，当线程获取不到任务时或者同步队列为空，线程的最大存活时间超过KeepAliveTime时，就会释放该空闲线程。

注意可调用对象包装器std::function和打包器std::bind的使用，通常使用这两种特性来作为生产者添加任务。using Task=std::function<void(void)>

在类中设置unordered_map<std::thread::id,std::shared_ptr<std::thread>> m_threadgroup来作为线程组管理线程。其中，m_coreThreadSize->核心线程数量，也作为缓存式线程池线程数下限，m_maxThreadSize->上限，最大线程数量，对于最大线程数量可以通过hardware_concurrency()来设置系统支持并发数量线程近似值.另外，还会有m_idleThreadSize->空闲线程数量，m_curThreadSize->当前线程池中线程总数量。

SyncQueue<Task> m_queue，在类中设置同步队列，并对同步队列进行初始化。

使用原子变量atomic_bool m_running。

以下提供线程池中主要函数功能：

void Start(int numthreads)//启动线程池
{
    m_running=true;
    m_curThreadSize=numthreads;//当前线程数量
    for(int i=0;i<numthreads;++i)
    {
        auto tha=std::make_shared<std::thread>(std::thread(&CachedThreadPool::RunInThread,this));
        std::thread::id tid=tha->get_id();
        m_threadgroup.emplace(tid,std::move(tha));
        m_idleThreadSize++;//空闲线程数++
    }
}

void RunInThread()//线程回调函数，启动线程，从缓冲区获取任务
{
    auto tid=std::this_thread::get_id();
    auto startTime=std::chrono::high_resolution_clock().now();
    while(m_running)
    {
        Task task;
        if(m_queue.size()==0&&m_queue.notTask())
        {
            auto now=std::chrono::high_resolution_clock().now();
            auto intervalTime=std::chrono::duration_cast<std::chrono::seconds>(now-startTime);
            std::lock_guard<std::mutex> lock(m_mutex);
                                if(intervalTime.count()>=KeepAliveTime&&m_curThreadSize>m_coreThreadSize)
            {
                m_threadgroup.find(tid)->second->deatch();//从主线程中分离出来该线程
                m_threadgroup.erase(tid);
                m_curThreadSize--;
                m_idleThreadSize--;
                return;
            }

        }
        if(!m_queue.Take(task)&&m_running)
        {
            m_idleThreadSize--;
            task();
            m_idleThreadSize++;
        }
    }
}

void StopThreadGroup()
{
    m_queue.Stop();
    m_running=false;
    for(auto& thread:m_threadgroup)
    {
        thread.second->join();
    }
    m_threadgroup.clear();
}

template<class Func,class...Args>
auto submit(Func&& func,Args&&... args)->std::future<decltype(func(args...))>
{
    using RetType=decltype(func(args...));
    auto task=std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<Func>(func),std::forward<Args>(args)...));
    std::future<RetType> result=task->get_future();
    if(m_queue.Put([task]() {(*task)();})!=0)
    {
        cout<<"调用者运行策略"<<endl;
        (*task)();
    }
    if(m_idleThreadSize<=0&&m_curThreadSize<m_maxThreadSize)
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        auto tha=std::make_shared<std::thread>(std::thread(&CachedThreadPool::RunInThread,this));
        std::thread::id tid=tha->get_id();
        m_threadgroup.emplace(tid,std::move(tha));
        m_idleThreadSize++;
        m_curThreadSize++;
    }
    return result;
}