C++跨平台线程池类

C++11+的一个跨平台的线程池封装类

#include <iostream>
#include <mutex>
#include <vector>
#include <functional>
#include <queue>
//类体
class CThreadPool {
public:
	CThreadPool() : m_stop(false), m_executionCount(0) {}
	~CThreadPool() {
		if (m_stop == false) {
			{
				std::unique_lock<std::mutex> lock(m_queueMutex);
				m_stop = true;
			}
			//通知所有线程做完任务
			m_condition.notify_all();
			//等待所有任务执行完成
			for (std::thread& worker : m_workers) {
				worker.join();
			}
			//printf("%s\n", __FUNCTION__);
		}
	}
	void Start(int numThreads) {
		for (int i = 0; i < numThreads; ++i) {
			this->AddThread();
		}
	}
private:
    //增加线程
	void AddThread(bool _loop = true/*是否循环利用线程*/) {
		m_workers.emplace_back([this, _loop] {
			do
			{
				std::function<void()> task;
				{
				    //序列锁
					std::unique_lock<std::mutex> lock(this->m_queueMutex);
					this->m_condition.wait(lock, [this] { return this->m_stop || !this->m_tasks.empty(); });
					if (this->m_stop && this->m_tasks.empty()) {
						//没有任何任务了直接结束
						return;
					}
					//取任务
					task = std::move(this->m_tasks.front());
					//弹出
					this->m_tasks.pop();
				}
				//执行
				m_executionCount++;
				task();
				{
					std::unique_lock<std::mutex> lock(this->m_executionCountMutex);
					m_executionCount--;
				}
			} while (_loop);
			}
		);
	}
public:
    //增加任务
	template<class F, class... Args>
	void AddTask(F&& f, Args&&... args) {
		{
			std::unique_lock<std::mutex> lock(m_queueMutex);
			m_tasks.emplace(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
		}
		m_condition.notify_one();
	}
	//自生自灭式启动线程
	template<class F, class... Args>
	void AddTaskAuto(F&& f, Args&&... args) {
		this->AddTask(f, args...);
		this->AddThread(false);
	}
	//任务线程总数
	int GetWorkeThreadCount() {
		int count = 0;
		{
			std::unique_lock<std::mutex> lock(this->m_queueMutex);
			count = (int)m_workers.size();
		}
		return count;
	}
	//待执行的任务数量
	int GetTaskCount() {
		int count = 0;
		{
			std::unique_lock<std::mutex> lock(this->m_queueMutex);
			count = (int)m_tasks.size();
		}
		return count;
	}
	//执行中的任务数量
	int GetExecutionCount() {
		int count = 0;
		{
			std::unique_lock<std::mutex> lock(this->m_queueMutex);
			count = (int)m_executionCount;
		}
		return count;
	}
	//执行和待执行
	int GetTaskAllCount() {
		int count = 0;
		{
			std::unique_lock<std::mutex> lock(this->m_queueMutex);
			count = m_executionCount + (int)m_tasks.size();
		}
		return count;
	}
	//等待所有任务结束
	int WaitForTask(int _timeOut = -1) {
		while (m_executionCount > 0) {
			//printf("%d\n", m_executionCount);
			std::this_thread::sleep_for(std::chrono::microseconds(10));
		}
		return m_executionCount;
	}
private:
	std::vector<std::thread> m_workers;			//线程数组
	std::queue<std::function<void()>> m_tasks;	//任务队列
	std::mutex m_queueMutex;					//互斥锁
	std::condition_variable m_condition;		//条件变量
	bool m_stop;								//结束标志
	std::mutex m_executionCountMutex;			//任务总数量互斥锁
	int m_executionCount;						//待执行和执行中的任务总数量
};

//调用例子：

//声明一个类，论场景使用，可直接设置静态类
CThreadPool g_threadPool;
//任务函数
void thread(int _a){
    //打印参数值
    printf("%d\n",a);
}

//1.固定线程型，一次启动十个异步线程
int main() {
    //初始化工作线程
	g_threadPool.Start(10);
	//启动
	for (int i = 0; i < 10; i++) {
		g_threadPool.AddTask(&thread, i);
	}

	return 0;
}

//2.自动管理型
int main() {
    //直接启动
	for (int i = 0; i < 10; i++) {
		g_threadPool.AddTaskAuto(thread, i);
	}

	return 0;
}

×

*转载请注明出处：原文链接：https://cpp.vin/page/7.html