转载一份C++线程池的代码，非常实用

最新推荐文章于 2024-06-03 16:23:52 发布
最新推荐文章于 2024-06-03 16:23:52 发布
阅读量796 收藏 1
点赞数 1
分类专栏： c++

转载自 http://blog.csdn.net/pjchen/archive/2004/11/06/170606.aspx

基本上是拿来就用了，对WIN32 API不熟，但对线程池的逻辑还是比较熟的，认为这个线程池写得很清晰，我拿来用在一个多线程下载的模块中。很实用的东东。
调用方法
void threadfunc(void *p)
{
     YourClass* yourObject = (YourClass*)    p;

 //...
}
 ThreadPool tp;
 for(i=0; i<100; i++)
  tp.Call(threadfunc);

ThreadPool tp(20);//20为初始线程池规模

 tp.Call(threadfunc, lpPara);
     

使用时注意几点：
1.  ThreadJob  没什么用，直接写线程函数吧。 
2. 线程函数（threadfunc）的入口参数void* 可以转成自定义的类型对象，这个对象可以记录下线程运行中的数据，并设置线程当前状态，以此与线程进行交互。
3. 线程池有一个EndAndWait函数，用于让线程池中所有计算正常结束。有时线程池中的一个线程可能要运行很长时间，怎么办？可以通过线程函数threadfunc的入口参数对象来处理，比如：
class YourClass {
  int cmd; // cmd = 1是上线程停止计算，正常退出。
};
threadfunc(void* p) {
  YourClass* yourObject = (YourClass*)p;
  while (true) {
    // do some calculation
    if (yourClass->cmd == 1)
      break;
  }
}
在主线程中设置yourClass->cmd = 1，该线程就会自然结束。
很简洁通用的线程池实现。 


#ifndef _ThreadPool_H_
#define _ThreadPool_H_
#pragma warning(disable: 4530)
#pragma warning(disable: 4786)
#include <cassert>
#include <vector>
#include <queue>
#include <windows.h>
using namespace std;
class ThreadJob  //工作基类
{
public:
	//供线程池调用的虚函数
	virtual void DoJob(void *pPara) = 0;
};
class ThreadPool
{
public:
	//dwNum 线程池规模
	ThreadPool(DWORD dwNum = 4) : _lThreadNum(0), _lRunningNum(0) 
	{
		InitializeCriticalSection(&_csThreadVector);
		InitializeCriticalSection(&_csWorkQueue);
		_EventComplete = CreateEvent(0, false, false, NULL);
		_EventEnd = CreateEvent(0, true, false, NULL);
		_SemaphoreCall = CreateSemaphore(0, 0,  0x7FFFFFFF, NULL);
		_SemaphoreDel =  CreateSemaphore(0, 0,  0x7FFFFFFF, NULL);
		assert(_SemaphoreCall != INVALID_HANDLE_VALUE);
		assert(_EventComplete != INVALID_HANDLE_VALUE);
		assert(_EventEnd != INVALID_HANDLE_VALUE);
		assert(_SemaphoreDel != INVALID_HANDLE_VALUE);
		AdjustSize(dwNum <= 0 ? 4 : dwNum);
	}
	~ThreadPool()
	{
		DeleteCriticalSection(&_csWorkQueue);
		CloseHandle(_EventEnd);
		CloseHandle(_EventComplete);
		CloseHandle(_SemaphoreCall);
		CloseHandle(_SemaphoreDel);
		vector<ThreadItem*>::iterator iter;
		for(iter = _ThreadVector.begin(); iter != _ThreadVector.end(); iter++)
		{
			if(*iter)
				delete *iter;
		}
		DeleteCriticalSection(&_csThreadVector);
	}
	//调整线程池规模
	int AdjustSize(int iNum)
	{
		if(iNum > 0)
		{
			ThreadItem *pNew;
			EnterCriticalSection(&_csThreadVector);
			for(int _i=0; _i<iNum; _i++)
			{
				_ThreadVector.push_back(pNew = new ThreadItem(this)); 
				assert(pNew);
				pNew->_Handle = CreateThread(NULL, 0, DefaultJobProc, pNew, 0, NULL);
				// set priority
				SetThreadPriority(pNew->_Handle, THREAD_PRIORITY_BELOW_NORMAL);
				assert(pNew->_Handle);
			}
			LeaveCriticalSection(&_csThreadVector);
		}
		else
		{
			iNum *= -1;
			ReleaseSemaphore(_SemaphoreDel,  iNum > _lThreadNum ? _lThreadNum : iNum, NULL);
		}
		return (int)_lThreadNum;
	}
	//调用线程池
	void Call(void (*pFunc)(void  *), void *pPara = NULL)
	{
		assert(pFunc);
		EnterCriticalSection(&_csWorkQueue);
		_JobQueue.push(new JobItem(pFunc, pPara));
		LeaveCriticalSection(&_csWorkQueue);
		ReleaseSemaphore(_SemaphoreCall, 1, NULL);
	}
	//调用线程池
	inline void Call(ThreadJob * p, void *pPara = NULL)
	{
		Call(CallProc, new CallProcPara(p, pPara));
	}
	//结束线程池, 并同步等待
	bool EndAndWait(DWORD dwWaitTime = INFINITE)
	{
		SetEvent(_EventEnd);
		return WaitForSingleObject(_EventComplete, dwWaitTime) == WAIT_OBJECT_0;
	}
	//结束线程池
	inline void End()
	{
		SetEvent(_EventEnd);
	}
	inline DWORD Size()
	{
		return (DWORD)_lThreadNum;
	}
	inline DWORD GetRunningSize()
	{
		return (DWORD)_lRunningNum;
	}
	bool IsRunning()
	{
		return _lRunningNum > 0;
	}
protected:
	//工作线程
	static DWORD WINAPI DefaultJobProc(LPVOID lpParameter = NULL)
	{
		ThreadItem *pThread = static_cast<ThreadItem*>(lpParameter);
		assert(pThread);
		ThreadPool *pThreadPoolObj = pThread->_pThis;
		assert(pThreadPoolObj);
		InterlockedIncrement(&pThreadPoolObj->_lThreadNum);
		HANDLE hWaitHandle[3];
		hWaitHandle[0] = pThreadPoolObj->_SemaphoreCall;
		hWaitHandle[1] = pThreadPoolObj->_SemaphoreDel;
		hWaitHandle[2] = pThreadPoolObj->_EventEnd;
		JobItem *pJob;
		bool fHasJob;
		for(;;)
		{
			DWORD wr = WaitForMultipleObjects(3, hWaitHandle, false, INFINITE);
			//响应删除线程信号
			if(wr == WAIT_OBJECT_0 + 1)  
				break;
			//从队列里取得用户作业
			EnterCriticalSection(&pThreadPoolObj->_csWorkQueue);
			if(fHasJob = !pThreadPoolObj->_JobQueue.empty())
			{
				pJob = pThreadPoolObj->_JobQueue.front();
				pThreadPoolObj->_JobQueue.pop();
				assert(pJob);
			}
			LeaveCriticalSection(&pThreadPoolObj->_csWorkQueue);
			//受到结束线程信号 确定是否结束线程(结束线程信号 && 是否还有工作)
			if(wr == WAIT_OBJECT_0 + 2 && !fHasJob)  
				break;
			if(fHasJob && pJob)
			{
				InterlockedIncrement(&pThreadPoolObj->_lRunningNum);
				pThread->_dwLastBeginTime = GetTickCount();
				pThread->_dwCount++;
				pThread->_fIsRunning = true;
				pJob->_pFunc(pJob->_pPara); //运行用户作业
				delete pJob; 
				pThread->_fIsRunning = false;
				InterlockedDecrement(&pThreadPoolObj->_lRunningNum);
			}
		}
		//删除自身结构
		EnterCriticalSection(&pThreadPoolObj->_csThreadVector);
		pThreadPoolObj->_ThreadVector.erase(find(pThreadPoolObj->_ThreadVector.begin(), pThreadPoolObj->_ThreadVector.end(), pThread));
		LeaveCriticalSection(&pThreadPoolObj->_csThreadVector);
		delete pThread;
		InterlockedDecrement(&pThreadPoolObj->_lThreadNum);
		if(!pThreadPoolObj->_lThreadNum)  //所有线程结束
			SetEvent(pThreadPoolObj->_EventComplete);
		return 0;
	}
	//调用用户对象虚函数
	static void CallProc(void *pPara) 
	{
		CallProcPara *cp = static_cast<CallProcPara *>(pPara);
		assert(cp);
		if(cp)
		{
			cp->_pObj->DoJob(cp->_pPara);
			delete cp;
		}
	}
	//用户对象结构
	struct CallProcPara  
	{
		ThreadJob* _pObj;//用户对象 
		void *_pPara;//用户参数
		CallProcPara(ThreadJob* p, void *pPara) : _pObj(p), _pPara(pPara) { };
	};
	//用户函数结构
	struct JobItem 
	{
		void (*_pFunc)(void  *);//函数
		void *_pPara; //参数
		JobItem(void (*pFunc)(void  *) = NULL, void *pPara = NULL) : _pFunc(pFunc), _pPara(pPara) { };
	};
	//线程池中的线程结构
	struct ThreadItem
	{
		HANDLE _Handle; //线程句柄
		ThreadPool *_pThis;  //线程池的指针
		DWORD _dwLastBeginTime; //最后一次运行开始时间
		DWORD _dwCount; //运行次数
		bool _fIsRunning;
		ThreadItem(ThreadPool *pthis) : _pThis(pthis), _Handle(NULL), _dwLastBeginTime(0), _dwCount(0), _fIsRunning(false) { };
		~ThreadItem()
		{
			if(_Handle)
			{
				CloseHandle(_Handle);
				_Handle = NULL;
			}
		}
	};
	std::queue<JobItem *> _JobQueue;  //工作队列
	std::vector<ThreadItem *>  _ThreadVector; //线程数据
	CRITICAL_SECTION _csThreadVector, _csWorkQueue; //工作队列临界, 线程数据临界
	HANDLE _EventEnd, _EventComplete, _SemaphoreCall, _SemaphoreDel;//结束通知, 完成事件, 工作信号， 删除线程信号
	long _lThreadNum, _lRunningNum; //线程数, 运行的线程数
};
#endif //_ThreadPool_H_


不屑哥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++线程池经典实现方式demo
05-10
C++线程池是一种高效的多线程管理机制，它允许我们将任务提交到一个预先创建好的线程集合中，由线程池统一管理和调度。这种方式可以避免频繁地创建和销毁线程，提高系统的性能和响应速度。下面将详细介绍C++线程池的...
一种类似JAVA线程池的C++线程池实现方法
08-25
本文讨论的是一种C++线程池实现，其设计灵感来源于Java的线程池。C++线程池的核心组件包括以下几个部分： 1. **IRunnable**：这是类似于Java中的`Runnable`接口，表示可执行的任务。它定义了`Run()`方法，供线程池...
一份C++线程池的代码，非常实用
weixin_30906671的博客
12-30 82
#ifndef _ThreadPool_H_ #define _ThreadPool_H_ #pragma warning(disable: 4530) #pragma warning(disable: 4786) #include <cassert> #include <vector> #include <queue> #include &l...
C++实现线程池详解
威桑的博客
06-03 632
Windows 下 C++ 实现线程池
转载一份C++线程池的代码，非常实用 .
王教余的专栏
12-31 1380
#ifndef _ThreadPool_H_#define _ThreadPool_H_#pragma warning(disable: 4530)#pragma warning(disable: 4786)#include #include #include #include using namespace std;class ThreadJob  //工作基类{public:  //供线程池调
转载一份C++线程池的代码，非常实用(转)
jphaoren的专栏
06-11 327
<br />#ifndef _ThreadPool_H_<br />#define _ThreadPool_H_<br />#pragma warning(disable: 4530)<br />#pragma warning(disable: 4786)<br />#include <cassert><br />#include <vector><br />#include <queue><br />#include <windows.h><br />using namespace std;<br />c
一份C++线程池的代码（转）
zhang_sinner的专栏
07-30 426
转载一份C++线程池的代码，非常实用 收藏 #ifndef _ThreadPool_H_ #define _ThreadPool_H_ #pragma warning(disable: 4530) #pragma warning(disable: 4786) #include #include #include #include using namespace std
一份C++线程池的代码
12-08 616
转载一份C++线程池的代码，非常实用 收藏 #ifndef _ThreadPool_H_#define _ThreadPool_H_#pragma warning(disable: 4530)#pragma warning(disable: 4786)#include #include #include #include using namespace std;class ThreadJo
[C++]_[线程池的简单实现]
zhyh1435589631的专栏
06-06 641
点我进入原文 写一点个人对代码的理解： 1. 创建一个线程池子 new 2. 激活线程池 （activate） - a, 创建各个空线程， start。     这个步骤中， start 会同时启动子线程 dotask， 这是一个while 循环， 他的业务逻辑是这样的， 当有任务的时候， 执行任务， 当没有任务的时候， 将线程放到空闲队列中， 同时调用 wait 等待，信号过来， 相
C/C++Linux服务器开发/后台架构师知识体系整理
qq_35303122的博客
03-06 697
C/C++Linux服务器开发/后台架构师知识体系整理
整理了一份FAQ，新手看一下
04-21 99
整理了一份FAQ，新手看一下 整理了一份FAQ，新手看一下 - 悄无声息的狗 - 博客园整理了一份FAQ，新手看一下一。UNIX/Linux环境篇Q：我想学Unix/Linux下的程序设计，该用什么语言？该看什么书？A：应该首选C。无论是Unix自身，还是其上运行...
c++ 线程池实现及安全队列
05-09
下面是一个简化的线程池实现的伪代码： ```cpp class ThreadPool { public: void enqueue(std::function()> task); // 提交任务 ~ThreadPool(); // 关闭线程池 private: std::vector<std::thread> workers; // ...
c++线程池及示例代码
08-24
在C++编程中，线程池是一种管理线程的有效机制，它通过预先创建一组线程，然后根据需要分配任务来提高程序的效率和响应性。线程池避免了频繁地创建和销毁线程带来的开销，同时能更好地控制系统的并发量，防止过度...
linux线程池代码（c++实现）
04-15
在Linux系统中，线程池是一种高效的多线程管理机制，它通过预先创建一组线程，然后将任务分配给这些线程执行，从而避免频繁地创建和销毁线程带来的开销。C++作为一门强大的系统编程语言，可以方便地实现线程池。下面...
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
cykooz.resizer-3.0.0-cp310-cp310-macosx_11_0_arm64.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]Delphi题库管理与试卷自动生成系统.zip
最新发布
07-27
[毕设]Delphi题库管理与试卷自动生成系统
写出一个c++线程池代码
05-14
以下是一个简单的 C++ 线程池代码，可以用于任务的并行处理： ```c++ #include <iostream> #include <queue> #include <thread> #include <mutex> #include <condition_variable> #include <functional> class ThreadPool { public: ThreadPool(size_t threads) : stop(false) { for (size_t i = 0; i < threads; ++i) workers.emplace_back( [this] { for (;;) { std::function<void()> task; { std::unique_lock<std::mutex> lock(this->queue_mutex); this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); }); if (this->stop && this->tasks.empty()) return; task = std::move(this->tasks.front()); this->tasks.pop(); } task(); } } ); } template<class F> void enqueue(F&& f) { { std::unique_lock<std::mutex> lock(queue_mutex); tasks.emplace(std::forward<F>(f)); } condition.notify_one(); } ~ThreadPool() { { std::unique_lock<std::mutex> lock(queue_mutex); stop = true; } condition.notify_all(); for (std::thread &worker : workers) worker.join(); } private: std::vector<std::thread> workers; std::queue<std::function<void()>> tasks; std::mutex queue_mutex; std::condition_variable condition; bool stop; }; ``` 在这个代码中，我们定义了一个 ThreadPool 类，它包含一个工作线程队列和一个任务队列，以及一个互斥锁和一个条件变量来保证线程安全。构造函数接受一个参数，表示要创建的工作线程的数量，然后创建相应数量的线程，并将它们加入工作线程队列中。enqueue() 方法用于将任务添加到任务队列中，同时通知一个工作线程来处理它。最后，在析构函数中，我们设置 stop 标志以通知所有线程退出，并等待所有线程完成工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值