C++线程池实现-优快云博客

线程池，简单来说就是有一堆已经创建好的线程（最大数目一定），初始时他们都处于空闲状态，当有新的任务进来，从线程池中取出一个空闲的线程处理任务，然后当任务处理完成之后，该线程被重新放回到线程池中，供其他的任务使用，当线程池中的线程都在处理任务时，就没有空闲线程供使用，此时，若有新的任务产生，只能等待线程池中有线程结束任务空闲才能执行，下面是C++实现线程池的方式
可以通过好几种方式来实现多线程的应用
是通过用来固定的线程来实现多任务一个一个执行，有以下两种方式来实现
1.在构造函数初始化的情况下来实现当前的线程创建和开启
2.在启动时来开启线程并开始执行
代码如下
#ifndef _THREADPOOL_HH
#define _THREADPOOL_HH

#include
#include
#include
#include
#include
#include

class ThreadPool
{
public:
int kInitThreadsSize = 3; //设置线程的数量
enum taskPriorityE { level0, level1, level2, };
typedef std::function<void()> Task;
typedef std::pair<taskPriorityE, Task> TaskPair;
enum EnumThreadMode { Mode_Already = 0 , Mode_StartCreate = 1 };

ThreadPool();    
ThreadPool(int ThreadNum, EnumThreadMode mode);
~ThreadPool();

//当前的开始进行相应的
void start();
void stop();
void addTask(const Task&);
void addTask(const TaskPair&);

private:
ThreadPool(const ThreadPool&);//禁止复制拷贝.
const ThreadPool& operator=(const ThreadPool&);

struct TaskPriorityCmp
{
    bool operator()(const ThreadPool::TaskPair p1, const ThreadPool::TaskPair p2)
    {
        return p1.first > p2.first; //first的小值优先
    }
};

void threadLoop();
Task take();

typedef std::vector<std::thread*> Threads;
typedef std::priority_queue<TaskPair, std::vector<TaskPair>, TaskPriorityCmp> Tasks;

Threads m_threads;
Tasks m_tasks;

std::mutex m_mutex;
std::condition_variable m_cond;
bool m_isStarted;
EnumThreadMode m_EnumThreadMode; //线程创建模式

};
#endif

#include <assert.h>

#include “ThreadPool.h”

ThreadPool::ThreadPool()
:m_mutex(),
m_isStarted(false)
{
m_EnumThreadMode = Mode_StartCreate; //模式位开始创建
}

ThreadPool::ThreadPool(int ThreadNum = 3, EnumThreadMode mode = Mode_Already)

m_isStarted(false)
{
m_EnumThreadMode = mode;
switch (mode)
{
default:
case ThreadPool::Mode_Already: //早就创建了
m_isStarted = true;
m_threads.reserve(kInitThreadsSize);
for (int i = 0; i < kInitThreadsSize; ++i)
m_threads.push_back(new std::thread(std::bind(&ThreadPool::threadLoop, this)));
break;
case ThreadPool::Mode_StartCreate: //开始创建了

break;
}
kInitThreadsSize = abs(ThreadNum);
}

ThreadPool::~ThreadPool()
{
if (m_isStarted) { stop(); }
for (Threads::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
{
if (*it != nullptr)
{
(it)->join();
delete it;
}
}
}

void ThreadPool::start()
{
std::unique_lockstd::mutex lock(m_mutex);
m_isStarted = true;
switch (m_EnumThreadMode)
{
default:
case ThreadPool::Mode_Already: //早就创建了
assert(!m_threads.empty());
break;
case ThreadPool::Mode_StartCreate: //开始创建了
assert(m_threads.empty());
m_threads.reserve(kInitThreadsSize);
for (int i = 0; i < kInitThreadsSize; ++i)
m_threads.push_back(new std::thread(std::bind(&ThreadPool::threadLoop, this)));
break;
}
}

void ThreadPool::stop()
{
{
std::unique_lockstd::mutex lock(m_mutex);
m_cond.notify_all();
}
switch (m_EnumThreadMode)
{
case ThreadPool::Mode_Already: //早就创建了

    break;
default:
case ThreadPool::Mode_StartCreate://开始的时候创建
    m_isStarted = false;
    for (Threads::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
    {
        if (*it != nullptr)
        {
            (*it)->join();
            delete* it;
        }
    }
    m_threads.clear();
    break;
}

}

//一直执行
void ThreadPool::threadLoop()
{
while (m_isStarted)
{
Task task = take();
if (task != nullptr)
{
task();
}
}
}

void ThreadPool::addTask(const Task& task)
{
std::unique_lockstd::mutex lock(m_mutex);
TaskPair taskPair(level2, task);
m_tasks.push(taskPair);
m_cond.notify_one();
}

void ThreadPool::addTask(const TaskPair& taskPair)
{
std::unique_lockstd::mutex lock(m_mutex);
m_tasks.push(taskPair);
m_cond.notify_one();
}

//处理回调
const ThreadPool& ThreadPool::operator=(const ThreadPool& Thread)
{
// TODO: 在此处插入 return 语句
return (*this);
}

ThreadPool::Task ThreadPool::take()
{
std::unique_lockstd::mutex lock(m_mutex);
//always use a while-loop, due to spurious wakeup
while (m_tasks.empty() && m_isStarted)
{
m_cond.wait(lock);
}

Task task;
Tasks::size_type size = m_tasks.size();
if (!m_tasks.empty() && m_isStarted)
{
    task = m_tasks.top().second;
    m_tasks.pop();
    assert(size - 1 == m_tasks.size());
}

return task;

}

本人水平有限，如果有错还望指出来，