服务器开发过程中经常遇到线程分配和高并发处理事务的问题,这个时候频繁的请求系统内核分配线程和释放线程,就会非常浪费宝贵的系统资源,所以这个时候线程池的作用就非常明显了,各位大侠有没有好的线程池的实现代码?

2010-12-25 01:04:15

3 Answers

名称:Threadpool
地址:

http://threadpool.sourceforge.net

说明:基于boost。需要vc6.0以上的版本才能编译,因为有long long类型以及模板嵌套。

名称:thread_pool
地址:

http://www.vckbase.com/code/winsys/mtask/threadpooldemosrc.rar

说明:基于boost。需要vc6.0以上的版本才能编译。

名称:dgc++
地址:

http://www.devguy.com/bb/viewtopic.php?p=1039.

说明:其中有线程池的实现,基于boost。需要vc6.0以上的版本才能编译。

名称:miniutil
地址:

http://www.devguy.com/bb/viewtopic.php?p=1039.

说明:其中有线程池的实现,需要vc6.0以上的版本才能编译。

名称:lightweight threadpool
地址:

http://miniutil.googlecode.com/files/miniutil_1_0.tar.gz

说明:轻量级的线程池,带有vc6.0工程文件。

2010-12-25 04:27:32
/****************************************************************** * Thread Pool For Win32 * VC++ 6, BC++ 5.5(Free), GCC(Free) * Update : 2004.6.9 llBird wushaojian@21cn.com Use: 1): void threadfunc(void *p) { //... } ThreadPool tp; for(i=0; i<100; i++) tp.Call(threadfunc); ThreadPool tp(20);//20为初始线程池规模 tp.Call(threadfunc, lpPara); tp.AdjustSize(50);//增加50 tp.AdjustSize(-30);//减少30 2): class MyThreadJob : public ThreadJob //线程对象从ThreadJob扩展 { public: virtual void DoJob(void *p)//自定义的虚函数 { //.... } }; MyThreadJob mt[10]; ThreadPool tp; for(i=0; i<100 i++) tp.Call(mt + i);//tp.Call(mt + i, para); *******************************************************************/ #ifndef _ThreadPool_H_ #define _ThreadPool_H_ #pragma warning(disable: 4530) #pragma warning(disable: 4786) #include <cassert> #include <vector> #include <queue> #include <windows.h> 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); 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_
2010-12-25 05:58:44

如果是在windows上开发,在xp之后,微软提供了线程池功能的函数,BindIoCompletionCallback和QueueUserWorkItem

2010-12-25 03:08:17
您不能回答该问题或者回答已经关闭!

相关文章推荐

  • C#实例解析适配器设计模式

    将一个类的接口变成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够一起工作

  • C#中using指令的几种用法

    using + 命名空间名字,这样可以在程序中直接用命令空间中的类型,而不必指定类型的详细命名空间,类似于Java的import,这个功能也是最常用的,几乎每个cs的程序都会用到

  • C#协变和逆变

    “协变”是指能够使用与原始指定的派生类型相比,派生程度更大的类型,“逆变”则是指能够使用派生程度更小的类型

  • C#运行时相互关系

    C#运行时相互关系,包括运行时类型、对象、线程栈和托管堆之间的相互关系,静态方法、实例方法和虚方法的区别等等

  • C#开发中的反射机制

    反射的定义:审查元数据并收集关于它的类型信息的能力。元数据(编译以后的最基本数据单元)就是一大堆的表,当编译程序集或者模块时,编译器会创建一个类定义表,一个字段定义表,和一个方法定义表等

  • 使用托管C++粘合C#和C++代码(二)

    本文实现一下C++代码调用C#代码的过程。我构造一个简单并且直观的例子:通过C++ UI 触发C# UI.

  • C#开发高性能Log Help类设计开发

    项目中要在操作数据库的异常处理中加入写Log日志,对于商业上有要求,写log时对其它操作尽可能影响小,不能因为加入log导致耗时太多

  • Async和Await使异步编程更简单

    C#5.0中async和await两个关键字,这两个关键字简化了异步编程,之所以简化了,还是因为编译器给我们做了更多的工作

  • C#中的索引器的简单理解和用法

    C#中的类成员可以是任意类型,包括数组和集合。当一个类包含了数组和集合成员时,索引器将大大简化对数组或集合成员的存取操作

  • C#基础概念之延迟加载

    延迟加载(lazy load)是Hibernate3关联关系对象默认的加载方式,延迟加载机制是为了避免一些无谓的性能开销而提出来的,所谓延迟加载就是当在真正需要数据的时候,才真正执行数据加载操作

  • 使用托管C++粘合C#和C++代码(一)

    C#在xml读写,数据库操纵,界面构造等很多方面性能卓越;C++的效率高,是底层开发的必备武器

  • 深入C# 序列化(Serialize)、反序列化(Deserialize)

    C#中的序列化和反序列化,序列化是.NET运行时环境用来支持用户定义类型的流化的机制