自己封装的线程类感觉还很不完善！大家提提看法以及建议

Question

初步打算使用模版实现，但本人比较懒所以只实现了一个Evnet#ifndef JADE_THREAD_H
#define JADE_THREAD_H
#include <windows.h>
#include "Jade_config_Thread_pool.h"
#include "Jade_MsgChain.h"
typedef unsigned (__stdcall *PTHREAD_START) (void *);
#define chBEGINTHREADEX(psa, cbStack, pfnStartAddr,    \
pvParam, fdwCreate, pdwThreadId)           \
((HANDLE)_beginthreadex(                   \
(void *)        (psa),                     \
(unsigned)      (cbStack),                 \
(PTHREAD_START) (pfnStartAddr),            \
(void *)        (pvParam),                 \
(unsigned)      (fdwCreate),               \
(unsigned *)    (pdwThreadId)))
/*----------------------------------------------------------------------------------
功能描述：一个线程的抽象表现，实现：运行、停止、重起、建立，销毁、
  任务的执行完成状态，
-----------------------------------------------------------------------------------*/
class Jade_ThreadByEvent
{
public:
Jade_ThreadByEvent();
/*使用消息链表*/
//Jade_ThreadByEvent(Jade_MsgChain *const lpMsgChain);
~Jade_ThreadByEvent();
public:
enum ThreadStatus{TLS_RUN = 0x00000001,TLS_STOP,TLS_KILL,TLS_COMPLETE,TLS_PENDING};
DWORD Create(DWORD dwStackSize,DWORD dwReturn = 0,DWORD dwLevel = 0,Jade_TaskBase *pTask = NULL);
void SetTimeOut(DWORD dwTime = INFINITE); //是否需要？
long GetTaskRunTime(long &dwTime) const; //取得线程运行时间
DWORD Run(Jade_TaskBase *pTask = NULL);
DWORD Suspend();
DWORD Stop();
DWORD Rerun();
DWORD Restart();
DWORD Kill();
DWORD CheckState(DWORD dwState);
DWORD ResetTask(Jade_TaskBase *pTask);
DWORD SetPriority(DWORD dwLevel);
DWORD DelTask();
DWORD IsEmpty();
DWORD GetMsg(TMSG &pMsg,UINT unBinMsg,UINT unEndMsg,UINT unMax);
private:
static DWORD CALLBACK ThreadProc(LPVOID lpParam);
static DWORD FilterCode(DWORD dwErrCode,LPVOID lpVoid);
DWORD Abend(DWORD dwCode = 0);
protected:
DWORD CheckRep(UINT unMsg,list<TMSG*> &lsObj,DWORD &dwCount,TMSG *pSwap = NULL);
private:
HANDLE m_hThread; //线程的实现描述
HANDLE m_hEvent[3]; //2-运行、1-停止、0-结束(线程状态)
HANDLE m_hWaitEvent[3]; //0-停止、1-结束(等待返回确认状态),2-任务执行时间,3-任务已完成
Jade_TaskBase *m_pTask; //所要执行的任务
DWORD m_dwReturn; //该线程的返回值
DWORD m_dwID; //线程ID
DWORD m_dwState; //线程状态:如运行，停止，销毁等状态
DWORD m_dwTimeOut; //线程执行超时
DWORD m_dwResult; //任务执行结果
long m_lTaskTime; //任务执行时间
list<TMSG*> m_lstMsg; //用于存储当前线程发生的事件消息
};
#if defined(__JADE_THREADPOOL_INLINE__)
#include "Jade_ThreadByEvent.inl"
#endif /*__JADE_THREAD_INLINE__*/
typedef list<Jade_ThreadByEvent*> List_ThreadByEvent;
typedef list<Jade_ThreadByEvent*>::iterator LPList_ThreadByEvent;
#endif

Answer 1

/*------------------------------------------------------------------------------------
说明：该文件用来进行编译选项以及一些错误信息，必要的基类，线程池使用的形参
  类型等信息的定义均在该头
-------------------------------------------------------------------------------------*/
#ifndef _JADE_CONFIG_THREAD_POOL__
#define _JADE_CONFIG_THREAD_POOL__#include <list>
#include <vector>
#include <map>
#include <utility>
using namespace std;#if defined(__JADE_THREADPOOL_NO_INLINE__)
#undef __JADE_THREADPOOL_INLINE__
#endif#if defined(__JADE_THREADPOOL_INLINE__)
#define JADE_THREADPOOL_INLINE inline
#else
#define JADE_THREADPOOL_INLINE
#endif#define JADE_OK 0x00000000 //操作成功
#define JADE_THREAD_ERROR_FULL 0x00000001 //线程池满
#define JADE_THREAD_ERROR_STOP 0x00000002  //该线程以停止
#define JADE_THREAD_ERROR_USED 0x00000003 //指定的线程被占用
#define JADE_LOCAL_MODEL 0x00000010 //
#define JADE_THREAD_CREATED 0x00000004 //线程已创建
#define JADE_THREAD_FAIL 0x00000005 //失败
#define JADE_THREAD_FALSE 0x00000006 //异常错误
#define JADE_THREAD_KILLED 0x00000007 //已删除
#define JADE_ALLOC_LOCAL 0x00000008 //TLS内存处理方式
#define JADE_ALLOC_GLOBAL 0x00000009 //全局内存分配方式
#define JADE_FALSE 0x0000000A //操作错误
#define JADE_TASK_FULL 0x0000000B //任务满
#define JADE_TASK_RUN 0x0000000C //任务正在执行
#define JADE_TASK_WAIT 0x0000000D //等待处理
#define JADE_LESSMEM 0x0000000E //内存不足
//begin(线程间通讯消息)
#define JADE_MANAGE_FILO#define THDM_DESTROY 0x00000000 //线程消亡-LOW 线程的结束代码
//   -HIGH 0 保留
#define THDM_CREATE 0x00000001 //线程建立-LOW 线程类型(以后可能添加资源线程以及窗口类型线程)
//   -HIGH 该类型线程的初始化信息(目前为CONTEXT)
#define THDM_INITIALIZE 0x00000002 //线程初始化 保留#define THDM_TASKCMP 0x00000003 //线程任务执行完毕 - LOW  任务所占用的时间片
// - HIGH 执行该任务的线程HANDLE
#define THDM_STOP 0x00000004 //处于等待状态 - LOW 线程的停止时间
// - HIGH 停止类型(指定在抵达时间后是否自动恢复其运行)
#define THDM_SUSPEND 0x00000005 //线程处于悬挂状态 - LOW 线程悬挂时间
// - HIGH 0 保留
#define THDM_RUNTASK 0x00000006 //处理事务 - LOW 0 保留
//   HIGH 0 保留
#define THDM_COPYDATA 0x00000007 //发送自定义数据 - LOW 0 保留
// - 指向_tagCOPYDATA结构体的指针
#define JM_NOREMOVE 0x00000000 //删除该消息
#define JM_REMOVE 0x00000001 //保留该消息typedef struct _tagTMSG
{
HANDLE hThread; //该消息的拥有者
UINT  dwMsg; //估计用4个数据位16进制表示应该足以
DWORD  dwLow; //因消息类型而定
DWORD  dwHigh; //因消息类型而定
long   ltime; //该消息生成时间
}TMSG,*PTMSG; //消息结构体typedef struct _tagCOPYDATA
{
DWORD dwSize; //lpData地址内的长度
PVOID lpData; //起始地址
}COPYDATA,*LPCOPYDATA;
//end(线程间通讯消息)
#define JADE_SUCCEEDED(dwStatus) ((DWORD)(dwStatus)==0)/*----------------------------------------------------------------------------------
功能说明: 任务处理基类使用者,请从该类进行子类化的派生。
每个抽象类必须实现TaskProc方法以便Jade_Thread
Pool调用您所需要的处理过程。
方法说明:
TaskProc 处理过程
OtherProc 保留处理过程
参数：
LPVOID pParam 目前为该任务类的this指针
DWORD dwID 该任务类所占用的线程ID
-----------------------------------------------------------------------------------*/
class Jade_TaskBase
{
public :
Jade_TaskBase(void)
{};
virtual ~Jade_TaskBase(void)
{};
public:
virtual DWORD TaskProc(LPVOID pParam,DWORD dwID) = 0;
virtual DWORD DestroyProc(DWORD dwEixt) = 0;
virtual DWORD OtherProc(LPVOID pParam,DWORD dwOther) = 0;
};typedef list<Jade_TaskBase*> List_Task;
typedef vector<Jade_TaskBase*> Vector_Task;
#endif

Answer 2

//Jade_ThreadByEvent.inl
/*------------------------------------------------------------------------------------
方法功能：检测线程运行状态
参数：
 Input:
DWORD dwState 检测状态
返回值：
 DWORD 线程当前的运行状态 失败
JADE_OK    成功
-------------------------------------------------------------------------------------*/
JADE_THREADPOOL_INLINE
DWORD Jade_ThreadByEvent::CheckState(DWORD dwState)
{
if(dwState == m_dwState)
return JADE_OK;
return m_dwState;
}
/*------------------------------------------------------------------------------------
方法功能：设置线程运行优先级
参数：
 Input:
DWORD dwLevel MSDN规定的优先级
返回值：
 DWORD 线程当前的运行状态 失败
JADE_OK    成功
-------------------------------------------------------------------------------------*/
JADE_THREADPOOL_INLINE
DWORD Jade_ThreadByEvent::SetPriority(DWORD dwLevel)
{
if(m_hThread != NULL)
{
if(!SetThreadPriority(m_hThread,dwLevel))
return JADE_OK;
else
return GetLastError();
}
return JADE_FALSE;
}
/*------------------------------------------------------------------------------------
方法功能：删除任务
参数：

返回值：
 DWORD 线程当前的运行状态 失败
JADE_OK    成功
-------------------------------------------------------------------------------------*/
JADE_THREADPOOL_INLINE
DWORD Jade_ThreadByEvent::DelTask()
{
if(m_pTask != NULL)
{
if(!JADE_SUCCEEDED(Stop()))
return JADE_FALSE;
m_pTask = NULL;
return JADE_OK;
}
JADE_FALSE;
}JADE_THREADPOOL_INLINE
DWORD Jade_ThreadByEvent::IsEmpty()
{
if(m_pTask != NULL)
return JADE_FALSE;
else
return JADE_OK;
}
JADE_THREADPOOL_INLINE
long Jade_ThreadByEvent::GetTaskRunTime(long &dwTime) const
{
DWORD dwObject = WaitForSingleObject(m_hWaitEvent[2],1000);
switch(dwObject)
{
case WAIT_TIMEOUT:

return JADE_FALSE;
case WAIT_OBJECT_0 + 0:
dwTime = m_lTaskTime;
return m_lTaskTime;
}
}
JADE_THREADPOOL_INLINE
DWORD Jade_ThreadByEvent::Stop()
{
ResetEvent(m_hEvent[2]);
return JADE_OK;
}
JADE_THREADPOOL_INLINE
DWORD Jade_ThreadByEvent::Rerun()
{
SetEvent(m_hEvent[2]);
return JADE_OK;
}

Answer 3

[code=C/C++]
#include "stdafx.h"
#include <time.h>
#include <process.h>
#include "Jade_MsgChain.h"
#include "Jade_ThreadByEvent.h"#if !defined(__JADE_THREADPOOL_INLINE__)
#include "Jade_ThreadByEvent.inl"
#endif /*__JADE_THREAD_INLINE__*/Jade_ThreadByEvent::Jade_ThreadByEvent():m_hThread(NULL),m_pTask(NULL),m_dwReturn(0),m_dwID(0)
   ,m_dwState(0),m_dwTimeOut(INFINITE),m_lTaskTime(0)
{
m_hEvent[0] = CreateEvent(NULL,TRUE,FALSE,NULL);
m_hEvent[1] = CreateEvent(NULL,TRUE,FALSE,NULL);
m_hEvent[2] = CreateEvent(NULL,TRUE,FALSE,NULL);
m_hWaitEvent[0] = CreateEvent(NULL,TRUE,FALSE,NULL);
m_hWaitEvent[1] = CreateEvent(NULL,TRUE,FALSE,NULL);
m_hWaitEvent[2] = CreateEvent(NULL,TRUE,FALSE,NULL);

}Jade_ThreadByEvent::~Jade_ThreadByEvent()
{
//Kill Thread
Kill();
//Kill Event
for(int i=0;i<3;i++)
{
if(m_hEvent[i]!=NULL)
{
CloseHandle(m_hEvent[i]);
m_hEvent[i] = NULL;
}
}
CloseHandle(m_hWaitEvent[0]);
CloseHandle(m_hWaitEvent[1]);
CloseHandle(m_hWaitEvent[2]);
ZeroMemory(m_hWaitEvent,sizeof(HANDLE)*2);
}
DWORD Jade_ThreadByEvent::Suspend()
{
if(JADE_SUCCEEDED(CheckState(TLS_STOP)))
{
return JADE_OK;
}
SetEvent(m_hEvent[1]);
return JADE_OK;
}
/*---------------------------------------------------------------------------------
方法说明：杀死线程---------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::Kill()
{
DWORD dwKill = 0,dwExitTime = 200;
if(m_hThread != NULL)
{
//检查线程状态
if(JADE_SUCCEEDED(CheckState(TLS_STOP)))
{
Restart();
}
SetEvent(m_hEvent[0]);
dwKill = WaitForSingleObject(m_hWaitEvent[1],INFINITE);
do
{
if(!GetExitCodeThread(m_hThread,&dwKill)||dwExitTime==1000)
{
Abend(); //异常非法结束
return GetLastError();
}
Sleep(dwExitTime);
dwExitTime++;
}while(dwKill != m_dwReturn);
CloseHandle(m_hThread);
m_hThread = NULL;
return JADE_OK;
}
return JADE_THREAD_KILLED;
}
/*---------------------------------------------------------------------------------------------
方法功能：建立线程，设定执行任务
参数：
Input:
DWORD dwStackSize 堆
DWORD dwReturn 返回值
LPVOID lpParam 任务的参数
JADE_TASKBASE* 任务
返回值：
DWORD 执行结果
----------------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::Create(DWORD dwStackSize,DWORD dwReturn,DWORD dwLevel,Jade_TaskBase *pTask)
{
if(m_hThread != NULL||m_dwID != 0)
return JADE_THREAD_CREATED;
__try
{
if(pTask != NULL)
{
m_hThread = chBEGINTHREADEX(NULL,dwStackSize,ThreadProc,this,0,&m_dwID);
if(m_hThread != NULL)
{
m_pTask = pTask;
m_dwState = TLS_RUN;
}
else
{
return GetLastError();
}
}
else
{
m_hThread = chBEGINTHREADEX(NULL,dwStackSize,ThreadProc,this,CREATE_SUSPENDED,&m_dwID);
if(m_hThread != NULL)
{
m_dwState = TLS_STOP;
}
else
{
return GetLastError();
}
}
if(dwLevel != 0 && m_hThread!=NULL)
{
if(!SetThreadPriority(m_hThread,dwLevel))
{
OutputDebugString("The Priority Failed/r/n");
}
}
m_dwReturn = dwReturn;

}
__except(FilterCode(GetExceptionCode(),this))
{
printf("线程创建错误\r\n");
return JADE_THREAD_FAIL;
}
return JADE_OK;
}
/*----------------------------------------------------------------------------------
方法说名：开始运行
参数：
input:
 Jade_TaskBase *pTask 执行的任务
返回值:
DWORD 执行结果
------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::Run(Jade_TaskBase *pTask)
{
if(pTask != NULL)
m_pTask = pTask;
switch(m_dwState)
{
case TLS_RUN:
SetEvent(m_hEvent[2]);
break;
case TLS_STOP:
Restart();
SetEvent(m_hEvent[2]);
break;
}
return JADE_OK;
}
/*-------------------------------------------------------------------------------------
方法说明：重新启动线程 注：将停止状态的线程置运行状态
--------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::Restart()
{
DWORD dwReturn = 0,dw = 0;
if(JADE_SUCCEEDED(CheckState(TLS_STOP)))
dwReturn = ResumeThread(m_hThread);
if(dwReturn == -1)
return GetLastError();
for(;dwReturn > 0;)
{
dwReturn = ResumeThread(m_hThread);
}
ResetEvent(m_hEvent[1]);
return JADE_OK;
}
/*---------------------------------------------------------------------------------------
方法说明：重新设置线程的任务
参数：
input:
 Jade_TaskBase *pTask 任务体
返回值：
DWORD 执行结果
----------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::ResetTask(Jade_TaskBase *pTask)
{
__try
{
if(pTask != NULL)
{
Stop();
m_pTask = pTask;
Restart();
}
}
__except(FilterCode(GetExceptionCode(),this))
{
char chCode[64] = { 0 };
DWORD dwResult = GetLastError();
sprintf(chCode,"Except Code is %d",dwResult);
OutputDebugString(chCode);
return JADE_THREAD_FALSE;
}
return JADE_OK;
}void Jade_ThreadByEvent::SetTimeOut(DWORD dwTime)
{
if(JADE_SUCCEEDED(CheckState(TLS_STOP)))
{
m_dwTimeOut = dwTime;
}
else
{
Stop();
m_dwTimeOut = dwTime;
Restart();
}
}
/*---------------------------------------------------------------------------------------
方法功能说明： 检查容器中重复消息的个数以及是否使用sSwap替换重复的消息
参数：
Input:
lsObj 受检查的容器
unMsg 重复的消息
Output:
dwCount 重复的元素个数
pSwap 非NULL则认为将使用该值替换重复元素
返回值: 
JADE_FALSE 操作异常
JADE_OK 操作正常
----------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::CheckRep(UINT unMsg,list<TMSG*> &lsObj,DWORD &dwCount,TMSG *pSwap)
{
list<TMSG*>::iterator itBin = lsObj.begin();
DWORD dwSum = 0;
__try
{
for(;itBin!=lsObj.end();itBin++)
{
if( (*itBin)->dwMsg == unMsg)
{
if(pSwap != NULL)
{
(*itBin)->dwLow = pSwap->dwLow;
(*itBin)->dwHigh = (DWORD)pSwap->hThread;
(*itBin)->ltime = clock();
(*itBin)->dwMsg = pSwap->dwMsg;
}
dwSum++;
}
}
}
__except(FilterCode(GetExceptionCode(),this))
{

return JADE_FALSE;
}
  dwCount = dwSum;
return JADE_OK;
}
[code]

Answer 4

/*--------------------------------------------------------------------------------------
方法说明： 线程实现体
参数：
input:
LPVOID lpParam Jade_Thread指针
返回值：
DWORD 执行结果
注：WaitForMultipleObjects有检查顺序所以运行状态要靠后，结束等待状态设置比较靠前
---------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::ThreadProc(LPVOID lpParam)
{
Jade_ThreadByEvent *pThis = static_cast<Jade_ThreadByEvent*>(lpParam);
DWORD dwReturn = pThis->m_dwReturn;
HANDLE hEvent[3] = { 0 };
char chBuf[128] = { 0 };
memcpy(hEvent,pThis->m_hEvent,sizeof(hEvent));
DWORD dwState = 0,dwCount = 0;
int   nOther = 0;
clock_t tStart =0,tFinish = 0;
__try
{
LOOP:
dwState = WaitForMultipleObjects(3,hEvent,FALSE,pThis->m_dwTimeOut);
switch(dwState)
{
case WAIT_OBJECT_0 + 2:
//Run
{
pThis->m_dwState = TLS_RUN;
if(pThis->m_pTask != NULL)
{
tStart = clock();
pThis->m_pTask->TaskProc(pThis->m_pTask,pThis->m_dwID);
tFinish = clock();
pThis->m_lTaskTime = tFinish - tStart;
TMSG *tMsg = new TMSG;
tMsg->dwMsg = THDM_TASKCMP;
tMsg->dwLow = tFinish;
tMsg->dwHigh = (DWORD)pThis->m_hThread;
tMsg->ltime = clock();
//保证该类型消息在消息队列中只有一个
pThis->CheckRep(THDM_TASKCMP,pThis->m_lstMsg,dwCount,tMsg);
if(dwCount == 0)
pThis->m_lstMsg.push_back(tMsg);
else
{
delete tMsg;
// sprintf(chBuf,"%d\r\n",dwCount);
// MessageBox(NULL,chBuf,"Tip",MB_OK|MB_ICONSTOP);
// ZeroMemory(chBuf,sizeof(chBuf));
}
SetEvent(pThis->m_hWaitEvent[2]);
}
}
break;
case WAIT_OBJECT_0 + 1:
//Stop
pThis->m_dwState = TLS_STOP;
SuspendThread(pThis->m_hThread);
//由于是线程内停止所以因该只能被执行一次
break;
case WAIT_OBJECT_0 + 0:
//Kill
pThis->m_dwState = TLS_KILL;
if(pThis->m_pTask != NULL)
pThis->m_pTask->DestroyProc(pThis->m_dwReturn);
return  SetEvent(pThis->m_hWaitEvent[1])?pThis->m_dwReturn:JADE_THREAD_FAIL;
break;
case WAIT_FAILED:
return JADE_THREAD_FALSE;
break;
}
goto LOOP;
}
__except(Jade_ThreadByEvent::FilterCode(GetExceptionCode(),pThis))
{
return JADE_THREAD_FALSE;
}
}
/*----------------------------------------------------------------------------------
方法功能：异常结束
参数说名：
 input:  
DWORD dwCode 异常结束码
返回值：
DWORD异常结束代码
----------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::Abend(DWORD dwCode)
{
char chCode[64] = { 0 };
if(dwCode == 0)
dwCode = GetLastError();
sprintf(chCode,"Abend Code is %d.\r\n",dwCode);
OutputDebugString(chCode);
TerminateThread(m_hThread,dwCode);
CloseHandle(m_hThread);
m_hThread = NULL;
return dwCode;
}
/*---------------------------------------------------------------------------------------
方法功能: 获取unBinMsg,unEndMsg之间的可用消息
参数:
Input:
unBinMsg 最小值消息
unEndMsg 最大值消息
unMax  最大尝试次数
Output:
pMsg 在unBinMsg与unEndMsg之间的可用消息
返回值:
待定
----------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::GetMsg(TMSG &pMsg,UINT unBinMsg,UINT unEndMsg,UINT unMax)
{
//首先停止线程的运作
UINT unRun = 0;
//取表首消息
DWORD dwRlt = WaitForSingleObject(m_hWaitEvent[2],INFINITE);
if(dwRlt == WAIT_OBJECT_0)
{
list<TMSG*>::iterator pMsgBin = m_lstMsg.begin();
int s = m_lstMsg.size();
for(;pMsgBin!=m_lstMsg.end();pMsgBin++)
{
if( (*pMsgBin)->dwMsg<=unBinMsg && (*pMsgBin)->dwMsg>=unBinMsg)
{
if((*pMsgBin)->hThread != NULL)
{
pMsg.dwHigh = (*pMsgBin)->dwHigh;
pMsg.dwLow = (*pMsgBin)->dwLow;
pMsg.dwMsg = (*pMsgBin)->dwMsg;
pMsg.hThread = (*pMsgBin)->hThread;
pMsg.ltime = (*pMsgBin)->ltime;
m_lstMsg.erase(pMsgBin);
return JADE_OK;
}
}
}
}
//消息队列中不包含可用的类型消息
return JADE_FALSE;
}
/*----------------------------------------------------------------------------------------
方法功能： 异常过滤
参数：
Input:
   dwErrCode 异常过滤码
   lpVoid  this指针
返回值：
待定
-----------------------------------------------------------------------------------------*/
DWORD Jade_ThreadByEvent::FilterCode(DWORD dwErrCode,LPVOID lpVoid)
{
Jade_ThreadByEvent *pThis = static_cast<Jade_ThreadByEvent*>(lpVoid);
char chCode[64] = { 0 };
switch(dwErrCode)
{
case EXCEPTION_ACCESS_VIOLATION:
sprintf(chCode,"线程%d访问内存地址违规.\r\n",pThis->m_dwReturn);
OutputDebugString(chCode);
//Other Except Proc
if(pThis->m_hThread != NULL)
pThis->Abend();
return dwErrCode;
case EXCEPTION_BREAKPOINT:

break;
case EXCEPTION_DATATYPE_MISALIGNMENT:

break;
case EXCEPTION_SINGLE_STEP:

break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:

break;
case EXCEPTION_FLT_DENORMAL_OPERAND:

break;
case EXCEPTION_FLT_DIVIDE_BY_ZERO:

break;
case EXCEPTION_FLT_INEXACT_RESULT:

break;
case EXCEPTION_FLT_INVALID_OPERATION:

break;
case EXCEPTION_FLT_OVERFLOW:

break;
case EXCEPTION_FLT_STACK_CHECK:

break;
case EXCEPTION_FLT_UNDERFLOW:

break;
case EXCEPTION_INT_DIVIDE_BY_ZERO:

break;
case EXCEPTION_INT_OVERFLOW:

break;
case EXCEPTION_PRIV_INSTRUCTION:

break;
case EXCEPTION_NONCONTINUABLE_EXCEPTION:

break;
default:
OutputDebugString("Unkown Error!\r\n");
break;
}
ExitThread(100000);
return dwErrCode;
}