线程池-std::function作为通用的任务

最新推荐文章于 2023-06-09 14:01:04 发布
最新推荐文章于 2023-06-09 14:01:04 发布
阅读量454 收藏 2
点赞数
分类专栏： 线程池 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caozhiyuan930204/article/details/118990386
版权

完整代码下载链接：

https://download.csdn.net/download/caozhiyuan930204/20418027

global.h

#ifndef _GLOBAL_H_
#define _GLOBAL_H_
#include <functional>
typedef std::function<void()> BaseTask;
#endif

首先是线程池

ThreadPool.h

#pragma once
#include<list>
#include "global.h"
#include "CStack.h"
#include "CList.h"
#include"CQueue.h"
#include "Singletion.h"
#include <mutex>
class CThread;
enum PRIORITY
{
	NORMAL,
	HIGH
};
class CBaseThreadPool 
{
	
public:
	virtual bool SwitchActiveThread(CThread*)=0;
};
class CThreadPool :public CBaseThreadPool, public Singletion<CThreadPool>
{
	friend class Singletion<CThreadPool>;
public:
	CThreadPool();
	~CThreadPool(void);
public:
	virtual void CreateThreadPool(int num);
	virtual CThread* PopIdleThread();
	virtual bool SwitchActiveThread(CThread*);
	virtual bool GetNewTask(BaseTask& task);
public:
	//priority为优先级。高优先级的任务将被插入到队首。
	bool addTask(BaseTask t, PRIORITY priority = NORMAL);
	bool start();//开始调度。
	bool destroyThreadPool();
private:
	int m_nThreadNum;
	bool m_bIsExit;
	
	CStack m_IdleThreadStack;
	CList m_ActiveThreadList;
	CQueue m_TaskQueue;
};

主要包含 空闲线程栈，正在使用线程列表和任务队列

CStack m_IdleThreadStack;
    CList m_ActiveThreadList;
    CQueue m_TaskQueue;

这里的单例模式是采用继承通用的单例模板类，需要声明友元类不然无法访问私有的构造函数

friend class Singletion<CMyThreadPool>;

Singletion.h

#ifndef _SINGLEGION_H_
#define _SINGLEGION_H_
#include <mutex>

template<class T>
class Singletion
{
public:
	static T* GetInstance()
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		if (NULL == m_pInstance)
		{
			m_pInstance = new T();
		}
		return m_pInstance;
	};
	static void ReleaseInstance()
	{
		if (m_pInstance != NULL)
		{
			delete m_pInstance;
			m_pInstance = NULL;
		}
	}
	virtual ~Singletion(){}
protected:
	Singletion(){}
private:
	static T* m_pInstance;
	static std::mutex m_mutex;
};
template<class T>
std::mutex Singletion<T>::m_mutex;

template<class T>
T* Singletion<T>::m_pInstance = NULL;
#endif

ThreadPool.cpp

#include "ThreadPool.h"
#include "CThread.h"
#include<cassert>
#include<iostream>
#include "CQueue.h"
#include "global.h"
CThreadPool::CThreadPool()
{
	m_bIsExit=false;
	
}
CThreadPool::~CThreadPool(void)
{
	
}

void CThreadPool::CreateThreadPool(int num)
{
	for (int i = 0; i<num; i++)
	{
		CThread*p = new CThread(this);
		m_IdleThreadStack.push(p);
		p->startThread();
	}
}
CThread* CThreadPool::PopIdleThread()
{
	CThread *pThread=m_IdleThreadStack.pop();
	//pThread->m_bIsActive=true;
	return pThread;
}
//将线程从活动队列取出，放入空闲线程栈中。在取之前判断此时任务队列是否有任务。如任务队列为空时才挂起。否则从任务队列取任务继续执行。
bool CThreadPool::SwitchActiveThread( CThread*t)
{
	if(!m_TaskQueue.isEmpty())//任务队列不为空，继续取任务执行。
	{
		BaseTask task;
		if (m_TaskQueue.pop(task))
		{
			std::cout << "线程：" << t->m_threadID << "   执行   ";// << pTask->getID() << std::endl;

			t->assignTask(task);
			t->startTask();
		}
	}
 	else//任务队列为空，该线程挂起。
	{
		m_ActiveThreadList.removeThread(t);
		m_IdleThreadStack.push(t);
	}
	return true;
}
bool CThreadPool::addTask(BaseTask t, PRIORITY priority)
{
	assert(t);
	if(!t||m_bIsExit)
		return false;	
//	std::cout<<"                                                   ["<<t->getID()<<"]添加！"<<std::endl;
	if(priority==PRIORITY::NORMAL)
	{
		m_TaskQueue.push(t);//进入任务队列。
	}
	else if(PRIORITY::HIGH)
	{
		m_TaskQueue.pushFront(t);//高优先级任务。
	}

	if(!m_IdleThreadStack.isEmpty())//存在空闲线程。调用空闲线程处理任务。
	{
		BaseTask task;
		if (!m_TaskQueue.pop(task))
		{
			std::cout << "任务取出出错。" << std::endl;
			return false;
		}
		CThread*pThread=PopIdleThread();
//		std::cout<<"【"<<pThread->m_threadID<<"】 执行   【"<<task->getID()<<"】"<<std::endl;
		m_ActiveThreadList.addThread(pThread);
		pThread->assignTask(task);
		pThread->startTask();	
	}
	return true;
}
bool CThreadPool::start()
{
	return 0;
}
bool CThreadPool::GetNewTask(BaseTask& task)
{
	if(m_TaskQueue.isEmpty())
	{
		return false;
	}
	m_TaskQueue.pop(task);//取出列头任务。
	return true;
}
bool CThreadPool::destroyThreadPool()
{
	
	m_bIsExit=true;
	m_TaskQueue.clear();
	m_IdleThreadStack.clear();
	m_ActiveThreadList.clear();
	return true;
}

CList

#pragma once
#include <list>
#include <mutex>
class CThread;
class CList
{
public:
	CList(void);
	~CList(void);
public:
	bool addThread(CThread*t);
	bool removeThread(CThread*t);
	int getSize();
	bool isEmpty();
	bool clear();

private:
	std::list<CThread*>m_list;
	std::mutex m_mutex;
};





--------------------------------------------------
#include "CList.h"
#include <cassert>
#include"CThread.h"
CList::CList(void)
{
}


CList::~CList(void)
{
}

bool CList::addThread( CThread*t )
{
	assert(t);
	if(!t)
		return false;
	std::lock_guard<std::mutex> lock(m_mutex);
	m_list.push_back(t);
	return true;
}

bool CList::removeThread( CThread*t )
{
	assert(t);
	if(!t)
		return false;
	std::lock_guard<std::mutex> lock(m_mutex);
	m_list.remove(t);
	return true;
}

int CList::getSize()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	int size= m_list.size();
	return size;
}

bool CList::isEmpty()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	bool ret= m_list.empty();
	return ret;
}

bool CList::clear()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	std::list<CThread*>::iterator iter=m_list.begin();
	for(;iter!=m_list.end();iter++)
	{
		delete (*iter);
	}
	m_list.clear();
	return true;
}

CQueue

#pragma once
#include<deque>
#include <mutex>
#include "global.h"
class CQueue
{
public:
	CQueue(void);
	~CQueue(void);
public:
	bool pop(BaseTask& t);
	//void pop();
	bool push(const BaseTask& t);
	bool pushFront(BaseTask& t);//插到队首。
	bool isEmpty();
	bool clear();
private:
	std::deque<BaseTask>m_TaskQueue;
	std::mutex m_mutex;
};



------------------------------------------------
#include "CQueue.h"

CQueue::CQueue(void)
{
}


CQueue::~CQueue(void)
{
}

bool CQueue::pop(BaseTask& p)
{
	std::lock_guard<std::mutex> lock(m_mutex);
	if(!m_TaskQueue.empty())
	{
		p=m_TaskQueue.front();
		m_TaskQueue.pop_front();
		return true;
	}
	return false;
}

bool CQueue::push(const BaseTask& t)
{
	if(!t)
	{
		return false;
	}
	std::lock_guard<std::mutex> lock(m_mutex);
	m_TaskQueue.push_back(t);
	return true;
}

bool CQueue::isEmpty()
{
	bool ret=false;
	std::lock_guard<std::mutex> lock(m_mutex);
	ret=m_TaskQueue.empty();
	return ret;
}

bool CQueue::pushFront(BaseTask& t)
{
	if(!t)
	{
		return false;
	}
	std::lock_guard<std::mutex> lock(m_mutex);
	m_TaskQueue.push_front(t);
	return true;
}

bool CQueue::clear()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	m_TaskQueue.clear();
	return true;
}

CStack

#pragma once
#include<stack>
#include <mutex>
class CThread ;
class CStack
{
public:
	CStack(void);
	~CStack(void);
public:
	CThread* pop();
	bool push(CThread*);
	int getSize();
	bool isEmpty();
	bool clear();
private:
	std::stack<CThread*> m_stack;
	std::mutex m_mutex;
};


-------------------------------------------------------------

#include "CStack.h"
#include<cassert>
#include"CThread.h"
CStack::CStack(void)
{
}
CStack::~CStack(void)
{
}
CThread* CStack::pop()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	if(!m_stack.empty())
	{
		CThread *t=m_stack.top();
		m_stack.pop();
		return t;
	}
	return NULL;
}
bool CStack::push( CThread* t)
{
	assert(t);
	if(!t)
		return false;
	std::lock_guard<std::mutex> lock(m_mutex);
	m_stack.push(t);
	return true;
}
int CStack::getSize()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	int size= m_stack.size();
	return size;
}
bool CStack::isEmpty()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	bool ret= m_stack.empty();
	return ret;
}
bool CStack::clear()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	CThread*pThread=NULL;
	while(!m_stack.empty())
	{
		pThread=m_stack.top();
		m_stack.pop();
		pThread->resumeThread();
		pThread->m_bIsExit=true;
		delete pThread;
	}
	return true;
}

CThread

#pragma once
#include "windows.h"
#include "global.h"
class CBaseThreadPool;
class CThread
{
public:
	CThread(CBaseThreadPool*threadPool);
	~CThread(void);
public:
	bool startThread();
	bool suspendThread();
	bool resumeThread();
	bool assignTask(BaseTask& pTask);
	bool startTask();
	static DWORD WINAPI threadProc(LPVOID pParam);
	DWORD m_threadID;
	HANDLE m_hThread;
	bool m_bIsExit;
private:
	
	HANDLE m_hEvent;
	BaseTask m_pTask;
	CBaseThreadPool*m_pThreadPool;	
};

-------------------------------------------------------------
#include "CThread.h"
#include "ThreadPool.h"
#include<cassert>
#define WAIT_TIME 20
CThread::CThread(CBaseThreadPool*threadPool)
{
	//m_bIsActive=false;
	m_pThreadPool=threadPool;
	m_hEvent=CreateEvent(NULL,false,false,NULL);
	m_bIsExit=false;
}

//bool CThread::m_bIsActive=false;
CThread::~CThread(void)
{
	CloseHandle(m_hEvent);
	CloseHandle(m_hThread);
}

bool CThread::startThread()
{
	m_hThread=CreateThread(0,0,threadProc,this,0,&m_threadID);
	if(m_hThread==INVALID_HANDLE_VALUE)
	{
		return false;
	}
	return true;
}
bool CThread::suspendThread()
{
	ResetEvent(m_hEvent);
	return true;
}
//有任务到来，通知线程继续执行。
bool CThread::resumeThread()
{
	SetEvent(m_hEvent);
	return true;
}

DWORD WINAPI CThread::threadProc( LPVOID pParam )
{
	CThread *pThread=(CThread*)pParam;
	while(!pThread->m_bIsExit)
	{
 		DWORD ret=WaitForSingleObject(pThread->m_hEvent,INFINITE);
		if(ret==WAIT_OBJECT_0)
		{
			pThread->m_pTask();//执行任务。
			pThread->m_pThreadPool->SwitchActiveThread(pThread);
		}
	}
	return 0;
}
//将任务关联到线程类。
bool CThread::assignTask(BaseTask& pTask)
{
	assert(pTask);
	if(!pTask)
		return false;
	m_pTask=pTask;
	
	return true;
}
//开始执行任务。
bool CThread::startTask()
{
	resumeThread();
	return true;
}

然后是使用，这里有两种使用方式，一种是全局函数，一种是类中静态函数作为任务

#include <iostream>
#include "ThreadPool.h"
#include "CThread.h"
#include "global.h"
static void add(int a, int b)
{
	printf("%d + %d = %d\n", a, b, a + b);
	return;
}

class TestTask
{
public:
	TestTask();
	~TestTask();
	void PostAddTest(int a, int b);
	void PostPrintTest(const std::string& strTest);

protected:
	static void AddTest(void* pTask, int a, int b);
	void HandleAddTest(int a, int b);

	
	static void PrintTest(void* pTask, const std::string& strTest);
	void HandlePrintTest(const std::string& strTest);
private:
};
TestTask::TestTask()
{
}
TestTask::~TestTask()
{

}
void TestTask::PostAddTest(int a, int b)
{
	CThreadPool::GetInstance()->addTask(std::bind(&TestTask::AddTest, this, a, b));
}

void TestTask::AddTest(void* pTask, int a, int b)
{
	TestTask* pTestTask = (TestTask*)pTask;
	pTestTask->HandleAddTest(a, b);
}
void TestTask::HandleAddTest(int a, int b)
{
	printf("a + b = %d\n", a + b);
}

void TestTask::PostPrintTest(const std::string& strTest)
{
	CThreadPool::GetInstance()->addTask(std::bind(&TestTask::PrintTest, this, strTest));
}
void TestTask::PrintTest(void* pTask, const std::string& strTest)
{
	TestTask* pTestTask = (TestTask*)pTask;
	pTestTask->HandlePrintTest(strTest);
}
void TestTask::HandlePrintTest(const std::string& strTest)
{
	printf("strTest = %s\n", strTest.c_str());
}
int main(int argc,char**argv)
{
	CThreadPool::GetInstance()->CreateThreadPool(4);
	//在类中使用
	//TestTask testTask;
	//for(int i=0;i<100;i++)
	//{		
	//	testTask.PostAddTest(i, i);
	//	testTask.PostPrintTest("hello");
	//}
	CThreadPool::GetInstance()->addTask(std::bind(&add, 4, 5));
	//主线程执行其他工作。
	{
		Sleep(1000*1000);
	}
	CThreadPool::GetInstance()->destroyThreadPool();
	CThreadPool::ReleaseInstance();
	return 0;
}

完整代码下载链接 

https://download.csdn.net/download/caozhiyuan930204/20418027

caozhiyuan930204
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++定义全局变量的两种方式
草上爬的博客
04-09 4万+
一、使用extern关键字cglobal.h#ifndef CGLOBAL_H #define CGLOBAL_H extern int testValue; #endif // CGLOBAL_Hcglobal.cpp#include "cglobal.h" int testValue=1;调用方式#include "cglobal.h" #include &lt;QDebug&gt; qD...
std::function的讲解与实战
06-30 426
c++中的std::function的讲解与实战。
ThreadPool:使用std的C ++线程池
04-29
线程池 使用std :: thread和其他C ++ 11/14标准线程实用程序的C ++线程池。 易于使用，具有一些额外功能，可以进行更多控制。 auto add(Func&& func, Args&&... args) 这是将作业添加到ThreadPool 。 接受要排队的可调用对象（ func ）以及参数（ args... ）。 返回模板Func的返回类型的std::future ，以获取返回值。 完整签名： template < typename> auto add (Func&& func, Args&&... args) -> std::future<typename>::type>; std::size_t threadCount() const 返回名称所隐
503-bind和function实现线程池
LINZEYU666的博客
08-30 123
#include <iostream> #include <typeinfo> #include <string> #include <memory> #include <vector> #include <functional> #include <thread> using namespace std; using namespace placeholders; //线程类 class Thread { public
基于C++ std::thread 的线程池
frodocheng的博客
07-17 1157
设计思路 算了，直接上代码，自己看吧。 /******************************************************* * @FileName: Task.h * @Author: Frodo Cheng * @CreatedTime: Jul 17th 2020 * @Description: * Wrapped thread pool task. ********************************************************
中级C++11：function、std::bind、线程库
FamerSaul的博客
07-06 558
std::function、function的使用、std::bind、std::bind的使用、线程库、thread类、线程对象的使用、原子性操作库：atomic、ios::operator bool、Mutex的种类、std::mutex、std::recursive_mutex、std::timed_mutex 、lock_guard 与 unique_lock 、条件变量：condition_variable、两个线程交替打印奇数偶数...
cpp代码-std::bind & function
07-16
cpp代码-std::bind & function
C++ 11 std::function和std::bind使用详解
08-25
主要介绍了C++ 11 std::function和std::bind使用详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C++线程编程-各种线程池
NINE_world的博客
04-09 1042
线程池 存放任务的线程安全队列 // 对比4.5 使用条件变量的线程安全队列的完整类定义 // 包含shared_ptr实例 #include <condition_variable> #include <mutex> #include <queue> #include <utility> #include <memory> template <typename T> class threadsafe_queue { private:
C++11 ThreadPool:一个易于使用的C ++ 11线程池。-开源
05-15
一个易于使用的C ++ 11线程池。 使用ThreadPool类对自由函数进行排队，并使用std :: for_each（）和std :: transform（）的并行版本。 可配置为仅用于标头或与库一起使用。 有许多用法示例。
C++ 线程池
weixin_39926429的博客
06-09 1279
//C++线程池是一种多线程技术，它可以在程序运行时创建一组线程， //并将任务分配给这些线程来执行。 //线程池可以提高程序的并发性和性能，特别是在处理大量任务时。
一个基于c++11的多线程池实现(std::thread)
XiaoHeiBlack的专栏
07-19 1128
需求分析 任何一个对性能有所要求的程序中，多线程是个绕不过去的优化手段。直接使用多线程并不能完全的发挥其作用。 假设某个算法的pipeline有N个模块M1,M2,M3,M4…MN。 首先若直接使用多线程技术，会导致我们在每个模块中都要重复一遍创建线程的操作，从而影响总体性能。 其次在这种重复创建线程的情况下也有可能会导致线程进入睡眠状态，而无法快速的利用CPU资源。所以由线程池统一的安排线程创建和调度就显得很有必要。 再考虑更复杂点的情况。M1到M5是需要多线程来加速，M6到M10不需要，随后M11到16
利用C++11的function和bind简化类创建线程
aguchu2119的博客
03-25 281
问题引出 当在类中需要创建线程时，总是因为线程函数需要定义成静态成员函数，但是又需要访问非静态数据成员这种需求，来做若干重复性的繁琐工作。比如我以前就经常定义一个静态成员函数，然后定一个结构体，结构体形式如下所示，将类指针传入到线程函数中以方便访问费非态成员变量。 struct THREAD_PARAMER { CTestClass* pThis; P...
Qt之回调函数：3 标准库function的用法
读书笔记
06-08 2829
文章目录一、简介二、使用三、std::function和函数指针相比有啥区别总结 std::function的用法 本文主要内容均摘自此文，看官可移步，未和此文作者取得联系，版权归原作者所有，此处厚个脸皮，直接转发其内容 一、简介 ​ 类模版std::function是一种通用、多态的函数封装类。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。std::function对象是对C++中现
c++11 线程池系列之一 最简单的线程池
Guyf的专栏
11-28 2872
线程池最简单的形式是含有一个固定数量的工作线程来处理任务，典型的数量是std::thread::hardware_concurrency(). 当有任务要处理时，调用一个函数将任务放到等待队列中。每个工作线程都是从该队列中取出任务，执行完任务后继续从等待队列取出更多的任务来处理。在最简单的情况，没有办法来等待一个任务完成。如需要这样的功能，则需要用户自己维护同步。 下面上代码 class t
std::function的用法
热门推荐
zeqi1991的博客
06-25 1万+
类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。std::function对象是对C++中现有的可调用实体的一种类型安全的包裹（我们知道像函数指针这类可调用实体，是类型不安全的）。 通常std::function是一个
C++11 线程池
weixin_27941997的博客
03-11 228
C++11实现线程池 根据网友提出的思路略有改动-----已测试 #pragma once #include<iostream> #include<thread> #include<list> #include<algorithm> #include<functional> #include<typeinfo> #include<mutex> #include<future> #include<atomic
STL---线程池的实现
小米的修行之路
08-06 1269
1、此线程池是GitHub上某位大牛的，地址：https://github.com/lizhenghn123/zl_threadpool。使用C++11技术实现的，如：std::thread，std::mutex，std::atomic、lambda表达式，future等等，如果你没接触过C++11中的这些技术的话，我相信你一定看不懂，你只需要把设计到的这些东西学习一下。 2、线程池实现： ...
C++学习之-std::make_unique 与std::unique_ptr
最新发布
09-22
std::make_unique 是 C++14 中引入的一个函数模板，用于创建一个指向动态分配对象的 std::unique_ptr。它的语法如下： ```cpp template, class... Args > std::unique_ptr<T> make_unique( Args&&... args ); ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值