完成端口

   整个服务由监听线程,工作线程构成.监听线程负责监听连接的到来,工作线程负责通知当有接受数据的到来.

服务头文件:
#pragma once
#include <vector>
using namespace std;
//IO操作类型标志
enum _OP_FLAG
{
    OP_NONE,
    OP_ACCEPT,
    OP_RECV,
    OP_SEND
};
//完成键结构
typedef struct tag_TCOMPLETIONPORT
{
   OVERLAPPED        Overlapped;
   WSABUF            DataBuf;
   CHAR                Buffer[1024*400];
   INT                nOvFlag;
} _TCOMPLETIONPORT, * _LPTCOMPLETIONPORT;

//登录到服务器的客户信息
class CClientInfo
{
public:
    // 重叠IO
    OVERLAPPED        Overlapped;       //关联的重叠IO变量
    WSABUF            DataBuf;          //IO的数据缓冲区
    _OP_FLAG        nOvFlag;            //完成状态标志 (op_recv,op_send,op_accept)
    SOCKET            sock;             //客户端套接字
    unsigned long   total_length;       //数据包的总长度
    unsigned long   pack_len;           //当前读取的长度
    char     RecvBuffer[1024*4];        //接收数据缓冲区
    char     DealBuffer[1024*4];        //一个通讯包的数据
    char     Buffer[1024*4];            //发送接收数据缓冲池       

    int                nSendBufferLen;  //发送数据大小
    bool            fIsLogin;           //是否登录
    int             nUserIndex;         //客户数据在链表的位置

    time_t          tConnectTime;       //连接到服务器的时间
    int             sendSpeed;          //发送短信的每秒最大速率，默认1条每秒
    int             LinkCheck;          //发送连接检查数据未响应次数，如果超过3次未响应则断开连接
public:
    CClientInfo(void)
    {
        sock=INVALID_SOCKET;
        total_length=0;
        pack_len=0;
    }
    ~CClientInfo(void)
    {
    }
   
    }
};

服务实现文件:


/****************************************************************************
 ///完成端口服务器
 ///编写人：秦柏林
 ///
 ///最后修改日期:2003-06-27
 ****************************************************************************/
#pragma once
#include <shlwapi.h>
#include <process.h>
#include "ServiceThread.h"


extern std::string LogFileName;              //日志文件名

//做日志记录
extern  void _stdcall PushLog(std::string LogMsg);
//判断连接IP是否有效
extern int _stdcall IsValidIP(CADOConnection& m_ADO,std::string IP);
//删除登录的客户端的记录
extern void DelLoginUser(CADOConnection& m_ADO,std::string UserID);
//将接收的数据包交给分析线程处理
extern int _stdcall DealRecvDataPacket(CClientInfo* pClient,CADOConnection& m_ADO);
//删除记录
extern void DeleteRecord(std::string OnlySign,std::string TableName,std::string KeyName,CADOConnection&  m_ADO);
//数据重发
extern void ReplyClient(CClientInfo* pClient,int replyType,unsigned int lresult/*只对登录回复有用*/,std::string MsgAnswerID);


HANDLE                g_hIOCP=NULL;             //完成端口句柄

int                   WaitTime=180;             //最大等待客户发送登录数据时间，默认1分钟，超过时间没有收到登陆数据断开连接
int                   CpuCount=2;               //服务务器cpu个数
double                SuperTime=180000;         //最大超时登录时间默认3分钟
CRITICAL_SECTION      Csec_Client;              //数据链表操作锁
//当前的客户连接
CWHDynamicArray<CClientInfo> smsClient;

std::string ServerPort="49100";                 //服务监听端口

CRITICAL_SECTION             Csec_log;
std::deque<std::string>      runLog;            //系统运行日志队列

std::string selfPath="";                        //文件所在路径


///

CThreadManage              ThreadManage;        //线程管理
bool                       IsIniVars=false;     //全局资源是否被初始化过


//
void  Lock(LPCRITICAL_SECTION crit_sec)
{
    ::EnterCriticalSection(crit_sec);
}
void  UnLock(LPCRITICAL_SECTION crit_sec)
{
    ::LeaveCriticalSection(crit_sec);
}
//初始化变量
int IniVariables()
{
    int result=0;
    TCHAR buf[512]={0};
    ::GetModuleFileName( NULL,buf, 512 );
    selfPath=buf;
    int pos=(int)selfPath.find_last_of('//');
    selfPath=selfPath.substr(0,pos);
    std::string logPath=selfPath+"//run_log";
    //判断文件夹是否存在
    if(!PathFileExists(logPath.c_str()))
    {
        //创建文件夹
        ::CreateDirectory(logPath.c_str(),NULL);
    }
    LogFileName=".//run_log//Service";
    if(!IsIniVars)
    {
        初始化winsock运行环境
        WSADATA        WSAData = { 0 };
        WORD WSA_VERSION=MAKEWORD(2,0);
        if ( 0 != WSAStartup(WSA_VERSION, &WSAData ))
        {
            PushLog("初始化socket环境失败");
            //关闭清除
            WSACleanup();
            PushLog("启动服务失败");
            return -1;
        }
        ::InitializeCriticalSection(&Csec_Client);
        ::InitializeCriticalSection(&Csec_log);
       
        CIniFile theFile(selfPath+"//Config.ini");
        //读取监听端口
        ServerPort=theFile.GetParamValue("smsQueue","ServerPort");
        //ManagePort=theFile.GetParamValue("smsQueue","ManagePort");
        //读取超时设置
        std::string strSuperTime=theFile.GetParamValue("smsQueue","SuperTime");
        char *stopstring;
        SuperTime=strtod(strSuperTime.c_str(),&stopstring);
        SuperTime=SuperTime*60*1000;
      
        g_hIOCP = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)NULL, 0);
        //创建完成端口
        if (g_hIOCP== NULL)
        {
            std::string msg="创建完成端口g_hIOCP失败";
            PushLog(msg);
            return 3;
            //创建完成端口失败
        }
        //cup个数
        SYSTEM_INFO  sysinfo;
        ::GetSystemInfo(&sysinfo);
        CpuCount=(int)sysinfo.dwNumberOfProcessors;
        result=1;
        IsIniVars=true;
    }
    else
    {
        result=1;
    }
    return result;
}
//
//通知完成端口退出
void NoticeCompletionExit()
{
    //退出端口等待
    if(g_hIOCP)
    {
        ::PostQueuedCompletionStatus(g_hIOCP,0,NULL,NULL);   
    }
}
void CloseSession(int nIndex)
{
    if(smsClient.GetData(nIndex))
    {
        //告诉客户端服务器要关闭
        if(smsClient.GetData(nIndex)->sock!=INVALID_SOCKET)
        {
            ReplyClient(smsClient.GetData(nIndex),0,0,"");
            smsClient.GetData(nIndex)->LoginName="";
            shutdown(smsClient.GetData(nIndex)->sock,SD_BOTH);
            closesocket(smsClient.GetData(nIndex)->sock);
            smsClient.GetData(nIndex)->sock=INVALID_SOCKET;
        }
        smsClient.SetEmptyElement(nIndex);
    }
}
void CloseSession(CClientInfo* pSession)
{
    if(pSession)
    {
        if(pSession->sock!=INVALID_SOCKET)
        {
            ReplyClient(pSession,0,0,"");
            pSession->LoginName="";
            pSession->fIsLogin=false;
            shutdown(pSession->sock,SD_BOTH);
            closesocket(pSession->sock);
            pSession->sock=INVALID_SOCKET;
        }
        smsClient.SetEmptyElement(pSession->nUserIndex);
    }
}
void CloseClientSession()
{
    //关闭所有终端连接
    try
    {
        Lock(&Csec_Client);
        int i=0;
        for(i=0;i<smsClient.m_nMaxIndex;i++)
        {
            CloseSession(i);
        }
        UnLock(&Csec_Client);
    }
    catch(...)
    {
        UnLock(&Csec_Client);
    }
}

void UnIniVariables()
{
    //CloseClientSession();
    if(IsIniVars)
    {
        ::DeleteCriticalSection(&Csec_Client);
        ::DeleteCriticalSection(&Csec_log);
        ::CloseHandle(g_hIOCP);
        g_hIOCP=NULL;
        WSACleanup();
        IsIniVars=false;
    }
}

///

///发出一次IO读请求
void PostRecv(CClientInfo* pSession,CADOConnection& m_ADO)
{
    try
    {
        DWORD nRecvBytes = 0;
        DWORD nFlags = 0;
        pSession->nOvFlag=OP_RECV;
        pSession->DataBuf.len=1024*4;
        memset(&(pSession->Overlapped),0,sizeof(OVERLAPPED));
        memset(pSession->Buffer,0,1024*4);
        pSession->DataBuf.buf=pSession->Buffer;
        pSession->pack_len=pSession->total_length=0;
        int result=0;
        result=WSARecv(pSession->sock,&(pSession->DataBuf),1,&nRecvBytes, &nFlags, &(pSession->Overlapped), 0 );
        *
        if(result==SOCKET_ERROR)
        {
            int Error=WSAGetLastError();
            if(Error!=WSA_IO_PENDING)//出错
            {
                从登录列表中删除用户
                std::string msg="";
               
                CloseSession(pSession);
               
                //*/
            }
        }
        ///*/
    }
    catch(...)
    {
      
    }
    return ;
}
///
//
///
///监听连接线程
///
unsigned int _stdcall AcceptThread(void* Param)           //接收短信客户端连接线程
{
    CThreadParam* pthread=(CThreadParam*)Param;
    std::string msg="";
    SOCKET  s =socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//使用TCP协议;
    if(s==INVALID_SOCKET)
    {
        pthread->ThreadEnd();
        msg="AcceptThread线程:创建监听的Socket失败";
        PushLog(msg);
        return 0;
    }
    try
    {
        int nPort=49100;//默认服务端口
        if(!ServerPort.empty())
        {
            nPort=atoi(ServerPort.c_str());
        }
        struct sockaddr_in    addr;
        addr.sin_family      = AF_INET;
        addr.sin_port        = htons((u_short)nPort);
        addr.sin_addr.s_addr= htonl(INADDR_ANY);    //针对服务器的所有网卡地址监听
       
        int                         nLen = sizeof(struct sockaddr_in);//地址长度
        SOCKET                      Accept=INVALID_SOCKET;            //接收客户连接
        struct sockaddr_in          Address;                          //客户端地址
        int                         optval=1 ;                        //Socket属性值
        unsigned long               ul=1;
        time_t                      dtnow;                            //连接的时间
        std::string                 IP("127.0.0.1");                  //连接过来的客户IP
        int ooptv=0;
        setsockopt(s,SOL_SOCKET,SO_EXCLUSIVEADDRUSE,(char*)&optval,sizeof(optval));  //禁止端口多用
        setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(char*)&optval,sizeof(optval));         //发送保持连接
        setsockopt(s,SOL_SOCKET,SO_SNDBUF,(char*)&ooptv,sizeof(ooptv));              //设置发送缓冲区
        setsockopt(s,SOL_SOCKET,SO_RCVBUF,(char*)&ooptv,sizeof(ooptv));              //设置接收缓冲区
        setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char*)&optval,sizeof(optval));         //不采用延时算法
        setsockopt(s,SOL_SOCKET,SO_DONTLINGER,(char*)&optval,sizeof(optval));        //执行立即关闭
        linger lng;
        lng.l_linger=0;
        lng.l_onoff=1;
        setsockopt(s,SOL_SOCKET,SO_LINGER,(char*)&lng,sizeof(lng));
        
        //设置非阻塞模式
        if(ioctlsocket(s,FIONBIO,(unsigned long*)&ul)==SOCKET_ERROR)
        {
            closesocket(s);
            s=INVALID_SOCKET;
            pthread->ThreadEnd();
            msg="AcceptThread线程:设置非阻塞模式失败";
            PushLog(msg);
            return 0;
        }
        //禁止重用本地端口
        if ((bind(s, (struct sockaddr *)&addr, sizeof( struct sockaddr_in))) == SOCKET_ERROR)
        {
            closesocket(s);
            s=INVALID_SOCKET;
            pthread->ThreadEnd();
            msg="AcceptThread线程:绑定Socket失败";
            PushLog(msg);
            return 0;
        }
        if ((listen(s, 5)) == SOCKET_ERROR)
        {
            msg="AcceptThread线程:监听Socket失败";
            pthread->ThreadEnd();
            closesocket(s);
            s=INVALID_SOCKET;
            PushLog(msg);
            return 0;
        }
        msg.resize(1000);
        sprintf_s((char*)msg.c_str(),1000,"AcceptThread线程:开始运行，在端口%d监听连接",nPort);
        PushLog(msg);
        CADOConnection m_adoConn;
        while(!m_adoConn.Open(adoConnString.c_str()))
        {
            msg="AcceptThread线程:连接数据库失败"+adoConnString;
            PushLog(msg);
            Sleep(10000);
        }
        while(!pthread->IsExit())
        {
            if(!m_adoConn.IsConnect())
            {
                m_adoConn.Open(adoConnString.c_str());
            }
            Accept=accept(s,(struct sockaddr *)&Address,&nLen);
            if(Accept!=INVALID_SOCKET)
            {
                //判断对方IP是否是合法的用户，否则直接断开
                IP=inet_ntoa(Address.sin_addr);//取得IP地址
                if(!IsValidIP(m_adoConn,IP)&&(IP!="127.0.0.1"))   //改用com函数中去处理
                {
                    closesocket(Accept);
                    Accept=INVALID_SOCKET;
                    Sleep(0);
                    continue;
                }
                //一个新的连接
                try
                {
                    Lock(&Csec_Client);
                    int nIndex=-1;
                    nIndex=smsClient.GetAvailablePosition();
                    if(nIndex>=0)
                    {
                        CClientInfo*  pNewUser=smsClient.GetEmptyElement(nIndex);
                        pNewUser->nUserIndex=nIndex;
                        pNewUser->IP=IP;
                        pNewUser->sock=Accept;
                        pNewUser->fIsLogin=false;     //未登录
                        time(&dtnow);
                        pNewUser->tConnectTime=dtnow; //连接的时间
                        pNewUser->LinkCheck=0;        //数据连接检查
                        ::CreateIoCompletionPort((HANDLE)pNewUser->sock,g_hIOCP, (ULONG_PTR)pNewUser, 0);//创建一个完成端口关联
                        //发出一次接收数据的IO请求
                        PostRecv(pNewUser,m_adoConn);//改用com函数处理
                    }
                    else
                    {
                        closesocket(Accept);
                        Accept=INVALID_SOCKET;
                      
                    }
                    UnLock(&Csec_Client);
                }
                catch(...)
                {
                    UnLock(&Csec_Client);
                }
            }
            else//利用空时间检查超时没有登录的客户端,断开它们
            {
                //检查超时未登录的
                Lock(&Csec_Client);
                try
                {
                    time_t nt;
                    time(&nt);
                    double waiteTime=0;
                    int i=0;
                    //使用
                    for(i=0;i<smsClient.m_nMaxIndex;i++)
                    {
                        if(smsClient.IsAvailableElement(i))
                        {
                            waiteTime=difftime(nt,smsClient.GetData(i)->tConnectTime);
                            if(!smsClient.GetData(i)->fIsLogin)
                            {
                                //直接断开连接
                                if(waiteTime>SuperTime)
                                {
                                    CloseSession(i);
                                }
                                Sleep(0);
                            }
                            else if(waiteTime>=SuperTime)//发送连接检测数据
                            {
                                ReplyClient(smsClient.GetData(i),8,0,"");
                                smsClient.GetData(i)->LinkCheck=smsClient.GetData(i)->LinkCheck+1;
                            }
                            else if(smsClient.GetData(i)->LinkCheck>3)//对于连续3次链路检测没有反应的断开连接
                            {
                                CloseSession(i);
                            }
                        }
                    }
                    UnLock(&Csec_Client);
                }
                catch(...)
                {
                    UnLock(&Csec_Client);
                }
            }
            Sleep(10);
        }
        m_adoConn.Close();
        shutdown(s,SD_BOTH);
        closesocket(s);
        s=INVALID_SOCKET;
        pthread->ThreadEnd();
        msg="AcceptThread线程:正常终止";
        PushLog(msg);
    }
    catch(...)
    {
        msg="AcceptThread线程:短信服务监听线程异常,10秒后线程自动重起";
        PushLog(msg);
        if(!pthread->IsExit()&&(pthread!=NULL))
        {
            //关闭所有连接的客户端
            CloseClientSession();
            Sleep(10000);
            HANDLE hwnd=NULL;
            unsigned int tid=0;
            ::CloseHandle(pthread->hThread);
            pthread->hThread=NULL;
            hwnd=(HANDLE)_beginthreadex(NULL,0,&AcceptThread,pthread,0,&tid);
            if(hwnd)
            {
                pthread->hThread=hwnd;
            }
        }
        else
        {
            pthread->ThreadEnd();
        }
    }
    shutdown(s,SD_BOTH);
    closesocket(s);
    s=INVALID_SOCKET;
    _endthreadex(0);
    return 0;
}

//
///完成端口的服务工作线程
///负责处理数据的收发操作
unsigned int _stdcall ServerWorkerThread(void* Param)     //服务工作线程
{
    CThreadParam* pthread=(CThreadParam*)Param;
    std::string msg="";
    try
    {
        DWORD                   dwBytesTransferred = 0;
        CClientInfo*            pSessionInfo = NULL;
        OVERLAPPED *            lpPerIoData = NULL;
       
        BOOL bSuccess=FALSE;
        int IsPost=1;
        while(!pthread->IsExit())
        {
            bSuccess=::GetQueuedCompletionStatus(g_hIOCP, &dwBytesTransferred, (PULONG_PTR)&pSessionInfo,&lpPerIoData,INFINITE);
            if(bSuccess!=0)//完成操作完成
            {
                if(pSessionInfo)
                {
                    IsPost=1;
                    if((dwBytesTransferred==0)&&((pSessionInfo->nOvFlag==OP_RECV)||(pSessionInfo->nOvFlag==OP_SEND)))//与完成端口关联的socketg关闭
                    {
                        DelLoginUser(m_adoConn,pSessionInfo->LoginName);
                        if(pSessionInfo->fIsLogin)
                        {
                            msg="终端<断开连接>："+pSessionInfo->departName+"，IP："+pSessionInfo->IP+"，登录ID："+pSessionInfo->LoginName;
                        }
                        else
                        {
                            msg="终端<断开连接>："+pSessionInfo->IP+"断开连接";
                        }
                        Lock(&Csec_Client);
                        try
                        {
                            CloseSession(pSessionInfo);
                            UnLock(&Csec_Client);
                        }
                        catch(...)
                        {
                            UnLock(&Csec_Client);
                        }
                        PushLog(msg);
                        continue;
                    }
                    //接收数据包
                    Lock(&Csec_Client);
                    try
                    {
                        if(pSessionInfo->nOvFlag==OP_RECV)
                        {
                            if((dwBytesTransferred>0))//(pSessionInfo->nOvFlag==OP_RECV)&&
                            {
                                //第一次收包
                                if(pSessionInfo->pack_len==0&&pSessionInfo->total_length==0)
                                {
                                    memset(pSessionInfo->RecvBuffer,0,1024*4);
                                    if(dwBytesTransferred<4)
                                    {
                                        //继续接收
                                        memcpy(pSessionInfo->RecvBuffer,pSessionInfo->DataBuf.buf,dwBytesTransferred);
                                        pSessionInfo->pack_len=dwBytesTransferred;
                                    }
                                    else
                                    {
                                        //取包的长度
                                        memcpy(&pSessionInfo->total_length,pSessionInfo->DataBuf.buf,4);
                                        pSessionInfo->total_length=ntohl(pSessionInfo->total_length);//包总长
                                        memcpy(pSessionInfo->RecvBuffer,pSessionInfo->DataBuf.buf,dwBytesTransferred);
                                        pSessionInfo->pack_len=dwBytesTransferred;
                                    }
                                }
                                else
                                {
                                    //第一次收包不足4个字节
                                    if(pSessionInfo->pack_len<4)
                                    {
                                        memcpy(pSessionInfo->RecvBuffer+pSessionInfo->pack_len,pSessionInfo->DataBuf.buf,dwBytesTransferred);
                                        pSessionInfo->pack_len=pSessionInfo->pack_len+dwBytesTransferred;
                                        if(pSessionInfo->pack_len>=4)
                                        {
                                            memcpy(&pSessionInfo->total_length,pSessionInfo->RecvBuffer,4);
                                            pSessionInfo->total_length=ntohl(pSessionInfo->total_length);//包总长
                                        }
                                    }
                                    else
                                    {
                                        memcpy(pSessionInfo->RecvBuffer+pSessionInfo->pack_len,pSessionInfo->DataBuf.buf,dwBytesTransferred);
                                        pSessionInfo->pack_len=pSessionInfo->pack_len+dwBytesTransferred;
                                    }
                                }
        DataDeal:
                                //一次收包完成的操作
                                if(pSessionInfo->total_length==pSessionInfo->pack_len&&pSessionInfo->pack_len!=0)//一次包接收完成
                                {
                                    memset(pSessionInfo->DataBuf.buf,0,1024*4);//清零
                                    memset(pSessionInfo->DealBuffer,0,1024*4);
                                    memcpy(pSessionInfo->DealBuffer,pSessionInfo->RecvBuffer,pSessionInfo->total_length);
                                    IsPost=DealRecvDataPacket(pSessionInfo,m_adoConn);//将接收数据交给数据分析处理线程
                                    pSessionInfo->total_length=0;
                                    pSessionInfo->pack_len=0;
                                }
                                if(pSessionInfo->total_length<pSessionInfo->pack_len&&pSessionInfo->pack_len!=0&&pSessionInfo->total_length>0)//一次包接收完成,并有超出一条记录的数据包
                                {
                                    memset(pSessionInfo->DataBuf.buf,0,1024*4);//清零
                                    memset(pSessionInfo->DealBuffer,0,1024*4);
                                    memcpy(pSessionInfo->DealBuffer,pSessionInfo->RecvBuffer,pSessionInfo->total_length);
                                    IsPost=DealRecvDataPacket(pSessionInfo,m_adoConn);//对数据分析处理
                                    char buf[4096]={0};
                                    memset(buf,0,4096);
                                    memcpy(buf,pSessionInfo->RecvBuffer+pSessionInfo->total_length,pSessionInfo->pack_len-pSessionInfo->total_length);
                                    memset(pSessionInfo->RecvBuffer,0,1024*4);
                                    memcpy(pSessionInfo->RecvBuffer,buf,pSessionInfo->pack_len-pSessionInfo->total_length);
                                    pSessionInfo->pack_len=pSessionInfo->pack_len-pSessionInfo->total_length;
                                    if(pSessionInfo->pack_len>=4)
                                    {
                                        memcpy(&pSessionInfo->total_length,pSessionInfo->RecvBuffer,4);
                                        pSessionInfo->total_length=ntohl(pSessionInfo->total_length);//包总长
                                    }
                                    if(pSessionInfo->total_length<=pSessionInfo->pack_len)//如果一次分包未结束，继续分包，直到不足一个结构包
                                    {
                                        goto DataDeal;
                                    }
                                }
                                //发出接收IO请求
                                if(IsPost==1)
                                {
                                    PostRecv(pSessionInfo,m_adoConn);
                                }
                            }                   
                        }
                        UnLock(&Csec_Client);
                    }
                    catch(...)
                    {
                        UnLock(&Csec_Client);
                    }
                }
               
                if((dwBytesTransferred==0)&&(pSessionInfo==NULL)&&(lpPerIoData==NULL))//收到线程结束信号
                {
                    break;
                }
            }
            else
            {
                if((lpPerIoData!=NULL)&&pSessionInfo)//偶发错误
                {
                    if(pSessionInfo)
                    {
                        Lock(&Csec_Client);
                        try
                        {
                            if(pSessionInfo->fIsLogin)
                            {
                                msg="终端<断开连接>："+pSessionInfo->departName+"，IP："+pSessionInfo->IP+"，登录ID："+pSessionInfo->LoginName;
                            }
                            else
                            {
                                msg="终端<断开连接>："+pSessionInfo->IP+"断开连接";
                            }
                            CloseSession(pSessionInfo);
                            UnLock(&Csec_Client);
                            PushLog(msg);
                        }
                        catch(...)
                        {
                            UnLock(&Csec_Client);
                        }
                    }
                }
            }
            Sleep(10);
        }
        m_adoConn.Close();
        msg="ServerWorkerThread:正常终止";
        PushLog(msg);
        pthread->ThreadEnd();
    }
    catch(...)
    {   
        if((!pthread->IsExit())&&(pthread!=NULL))
        {
            msg="ServerWorkerThread:出现异常，1秒后自动从新开始";
            PushLog(msg);
            Sleep(1000);
            HANDLE hwnd=NULL;
            unsigned int tid=0;
            ::CloseHandle(pthread->hThread);
            pthread->hThread=NULL;
            hwnd=(HANDLE)_beginthreadex(NULL,0,&ServerWorkerThread,pthread,0,&tid);
            if(hwnd)
            {
                pthread->hThread=hwnd;
            }
        }
        else
        {
            pthread->ThreadEnd();
        }
    }
    _endthreadex(0);
    return 0;
}