线程池

最新推荐文章于 2024-07-26 09:50:12 发布

zyc_sinacom

最新推荐文章于 2024-07-26 09:50:12 发布

阅读量528

点赞数

文章标签：服务器 winapi null microsoft 数据库连接池 delete

服务器程序利用线程技术响应客户请求已经司空见惯,可能您认为这样做效率已经很高，但您有没有想过优化一下使用线程的方法。该文章将向您介绍服务器程序如何利用线程池来优化性能并提供一个简单的线程池实现。
线程池的技术背景

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来服务就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。比如大家所熟悉的数据库连接池正是遵循这一思想而产生的，本文将介绍的线程池技术同样符合这一思想。

目前，一些著名的大公司都特别看好这项技术，并早已经在他们的产品中应用该技术。比如IBM的WebSphere，IONA的Orbix 2000在SUN的 Jini中，Microsoft的MTS（Microsoft Transaction Server 2.0），COM+等。

现在您是否也想在服务器程序应用该项技术?

线程池技术如何提高服务器程序的性能

我所提到服务器程序是指能够接受客户请求并能处理请求的程序，而不只是指那些接受网络客户请求的网络服务器程序。

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。但如果对多线程应用不当，会增加对单个任务的处理时间。可以举一个简单的例子：

假设在一台服务器完成一项任务的时间为T

T1 创建线程的时间
T2 在线程中执行任务的时间，包括线程间同步所需时间
T3 线程销毁的时间

显然T ＝ T1＋T2＋T3。注意这是一个极度简化的假设。

可以看出T1,T3是多线程本身的带来的开销，我们渴望减少T1,T3所用的时间，从而减少T的时间。但一些线程的使用者并没有注意到这一点，所以在程序中频繁的创建或销毁线程，这导致T1和T3在T中占有相当比例。显然这是突出了线程的弱点（T1，T3），而不是优点（并发性）。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目。在看一个例子：

假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。我们比较利用线程池技术和不利于线程池技术的服务器处理这些请求时所产生的线程总数。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目或者上限（以下简称线程池尺寸），而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池尺寸是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

这些都是假设，不能充分说明问题，下面我将讨论线程池的简单实现并对该程序进行对比测试，以说明线程技术优点及应用领域。
现在来实现一下线程池
class ThreadPoolManage
{
private:
ThreadPoolManage();
virtual~ThreadPoolManage();
private:
static ThreadPoolManage *m_ThreadPool;
static CArray<TemporaryThread *,TemporaryThread *> m_Temporarily; //临时线程
static CArray<ManageThread *,ManageThread *> m_ManageThread;      //最初线程
static CCriticalSection section;
public:
static ThreadPoolManage * GetThreadPoolManage();
static void CloseThreadPoolManage();
protected:
    //线程回调函数
static DWORD WINAPI ExcuteMession(LPVOID n);
static DWORD WINAPI ExcuteLeisureMession(LPVOID n);
private:
//加入工作任务
bool AddTask(Task *inTask);
bool IsAddTask();
    //起动与停止线程池
bool StartThreadPool(int inCount);
bool StopThreadPool();
///关闭一到多个空闲线程返回关闭的线程数
int CloseTemporarilyThread(int count);
//线程池中的总的线程数
int GetThreadPoolCount();
};
#endif
#include "Task.h"
class ManageThread
{
private:

HANDLE mhThread;//线程句柄
HANDLE mhEvent;//事件句柄(结束空闲线程通知)
CSemaphore *m_sesction;//信号量
Task *pTask;
public:
ManageThread();
virtual~ManageThread();
public:

//线程操作
bool ExcuteThread();
bool PostExitThread();
bool TerminateExitThread();
bool GetThreadIsLisure();//线程是否空闲
bool SetLockThread(int tm=0);//锁定当前线程(参数tm代表的是时间)
//字柄操作
HANDLE GetThreadEvent();
HANDLE GetThreadHandle();
void  SetThreadHandle(HANDLE handle);
    //设置当前线程工作的任务
void SetThreadTask(Task *inTask);
};
#endif
class Task
{
public:
Task();
virtual ~Task();
public:
virtual void ExcuteTask()=0;
};
#endif
任务类说明:
这是我开发的一个UDP传输的类
class UdpTask :public Task

{

private:

SOCKET mSckSender;

HANDLE hRecThread;

UdpClientInfo mInfor;

bool mIsSend;

int mSlindindWin;//可滑动窗口数

list<WaitDefiniteData *> mWaitDefineList;

double SuperTime;//超时时间(最小不得小到2秒)(=传送前一个数据片的2倍)

FILE * pFlie;

byte * _svd;

public:

UdpTask();

virtual ~UdpTask();

void ExcuteTask();

void SetClientInfo(CString inPath,RemoteEP inEP);

protected:

private:

bool InitFile();

void SendFileLoop();//发送文件

void SendTcpConn();//转TCP连接

void SendSampleEnd();//发送完毕

BOOL HeavyspreadSample();//重传检索

void SendSpreadSample(WaitDefiniteData *inData);//重传一个数据包

void ConfirmSample(int inNum );//滑动窗口有关

//发送SOCKET打操作

bool CreateSender();

void DelecteSender();

bool Send(const char * inBuffer,int inLength);

//接受数据线程

BOOL StartReceiving();

void StopRecveiving();

void RecveivingLoop();

static DWORD WINAPI ReceivingThrd(void *pParam);

};

#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);

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

zyc_sinacom

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程池

服务器程序利用线程技术响应客户请求已经司空见惯,可能您认为这样做效率已经很高，但您有没有想过优化一下使用线程的方法。该文章将向您介绍服务器程序如何利用线程池来优化性能并提供一个简单的线程池实现。线程池的技术背景在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。
复制链接

扫一扫