（14）C++算法---自定义的线程池

需要并行处理多个细小的任务时，不需频繁创建销毁线程

ThreadPool.h

#pragma once

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

class ThreadPool
{
public:
	//线程大小，即线程池中创建的线程的个数
	static const int kInitThreadsSize = 10;
	//线程池中的函数任务优先级枚举，共定义三个级别的优先级状态
	enum eTaskPriority { level0, level1, level2, };
	ThreadPool();
	~ThreadPool();
	//线程池启动函数
	void start();
	//线程池停止
	void stop();
	//往线程池中添加任务，默认任务优先级为2
	void addTask(const std::function<void()>&);
	//往线程池中添加任务，eTaskPriority为其优先级
	void addTask(const std::pair<eTaskPriority, std::function<void()>>&);
private:
	ThreadPool(const ThreadPool&);//禁止复制拷贝.
	//线程池中优先队列的排序规则，level0为最高优先级，这里不太了解的看博文https://blog.csdn.net/qq_33628827/article/details/107591845
	struct TaskPriorityCmp
	{
		bool operator()(const std::pair<eTaskPriority, std::function<void()>>&p1, const std::pair<eTaskPriority, std::function<void()>>&p2)
		{
			return p1.first > p2.first; //first的小值优先
		}
	};
	void threadLoop();
	//提取任务执行
	std::function<void()>take();
	//线程池中的线程
	std::vector<std::thread*> m_threads;
	//线程池中的任务，保存在优先队列中，其中的排列规则按照高优先级在栈顶的规则
	std::priority_queue<std::pair<eTaskPriority, std::function<void()>>, std::vector<std::pair<eTaskPriority, std::function<void()>>>, TaskPriorityCmp> m_tasks;

	std::mutex m_mutex;
	//条件变量，用于阻塞与通知线程池的执行与否
	std::condition_variable m_cond;
	//线程池启动标志
	bool m_isStarted;

};

ThreadPool.cpp

#include "ThreadPool.h"

ThreadPool::ThreadPool():
	m_mutex(),
	m_cond(),
	m_isStarted(false)
{

}

ThreadPool::~ThreadPool()
{
}

void ThreadPool::start()
{
	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)));
	}
}

void ThreadPool::stop()
{
	std::unique_lock<std::mutex> lock(m_mutex);
	m_isStarted = false;
	m_cond.notify_all();

	for (std::vector<std::thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
	{
		(*it)->join();
		delete *it;
	}
	m_threads.clear();
}

void ThreadPool::addTask(const std::function<void()>&task)
{
	std::unique_lock<std::mutex> lock(m_mutex);
	/*while(m_tasks.isFull())
	  {//when m_tasks have maxsize
		cond2.wait();
	  }
	*/
	std::pair<eTaskPriority, std::function<void()>> taskPair(level2, task);
	m_tasks.push(taskPair);
	m_cond.notify_one();
}

void ThreadPool::addTask(const std::pair<eTaskPriority, std::function<void()>>&taskPair)
{
	std::unique_lock<std::mutex> lock(m_mutex);
	m_tasks.push(taskPair);
	//当添加任务的时候通知线程池取任务执行
	m_cond.notify_one();
}

void ThreadPool::threadLoop()
{
	//线程池循环函数
	while (m_isStarted)
	{
		std::function<void()> task = take();
		if (task)
		{
			task();
		}
	}
}

std::function<void()> ThreadPool::take()
{
	std::unique_lock<std::mutex> lock(m_mutex);
	//线程中任务为空时阻塞
	while (m_tasks.empty() && m_isStarted)
	{
		//当m_con notify的时候就不阻塞
		m_cond.wait(lock);
	}
	//线程中任务非空时，取顶端任务执行
	std::function<void()> task;
	std::priority_queue<std::pair<eTaskPriority, std::function<void()>>, std::vector<std::pair<eTaskPriority, std::function<void()>>>, TaskPriorityCmp>::size_type size = m_tasks.size();
	if (!m_tasks.empty() && m_isStarted)
	{
		task = m_tasks.top().second;
		m_tasks.pop();
	}
	return task;
}

线程池的调用

std::mutex g_mutex;

void priorityFunc()
{
	for (int i = 1; i < 4; ++i)
	{
		std::this_thread::sleep_for(std::chrono::seconds(1));		
	}
	std::lock_guard<std::mutex> lock(g_mutex);
	cout << "priorityFunc()" << std::endl;
}

void testFunc()
{
	// loop to print character after a random period of time
	for (int i = 1; i < 4; ++i)
	{
		std::this_thread::sleep_for(std::chrono::seconds(1));
				
	}
	std::lock_guard<std::mutex> lock(g_mutex);
	cout << "testFunc()" << std::endl;
}
int main()
{
	ThreadPool threadPool;
	threadPool.start();

	for (int i = 0; i < 120; i++)
		threadPool.addTask(testFunc);

	std::this_thread::sleep_for(std::chrono::seconds(1));

	threadPool.addTask(std::pair<ThreadPool::eTaskPriority, std::function<void()>>(ThreadPool::level0, priorityFunc));

	system("pause");
	return 0;

}