嫁给程序员

    if(hIocp)
    {
        PostQueuedCompletionStatus(hIocp,1,
            reinterpret_cast<ULONG_PTR>(&PreSockData),
            reinterpret_cast<LPOVERLAPPED>(&PreIoData));

18.
除了各个月买一本书,就不曾任何需求花钱的地点,剩下的钱只可以变着法的给爱妻买各类首饰和服装。

    if(hFile!=INVALID_HANDLE_VALUE)
    {
        cout<<“Transmit File “<<pIoData->Buffer<<”
to client”<<endl;
        pIoData->IoType=IoTransFile;
        memset(&pIoData->oa,0,sizeof(OVERLAPPED));
        *reinterpret_cast<HANDLE*>(pIoData->Buffer)=hFile;
        TransmitFile(pSocketData->hSocket,hFile,GetFileSize(hFile,NULL),PRE_SEND_SIZE,reinterpret_cast<LPOVERLAPPED>(pIoData),NULL,TF_USE_SYSTEM_THREAD);
        bRet=WSAGetLastError()==WSA_IO_PENDING;
    }
    else
        cout<<“Transmit File
“<<“Error:”<<GetLastError()<<endl;

  1. 太太能够对负有的二哥、四妹宣称:“你们的结束学业设计我全包了……”

#pragma comment(lib,”ws2_32.lib”)
#pragma comment(lib,”mswsock.lib”)

20.
每一天都被Bug和客户双重折磨,有极好的耐心和保持,即便跟老婆吵架也能维持温和和萧索,不太也许说出不理智的话伤了老伴的心。

    return bRet;
}

  1. 会帮老伴把菜谱改写成if…then…do while的格式,并且蕴涵美貌的缩进。

char* TimeNow(void)
{
    time_t t=time(NULL);
    tm *localtm=localtime(&t);
    static char timemsg[512]={0};
    
    strftime(timemsg,512,”%Z: %B %d %X,%Y”,localtm);
    return timemsg;
}

  1. 一套服装穿四个月!

BOOL TransFile(PPRE_IO_DATA pIoData,PPRE_SOCKET_DATA
pSocketData,DWORD dwNameLen)
{
    //这一句是为nc做的,你能够修改它
    pIoData->Buffer[dwNameLen-1]=’/0′;
    
    HANDLE
hFile=CreateFile(pIoData->Buffer,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
    BOOL bRet=FALSE;

14.
假诺现在孩子嫌背单词太平淡,老婆就足以把程序员的代码拿给他看:“看你老爸为了背单词,重复了稍稍遍if
else for 和 string啊?!”

DWORD WINAPI ThreadProc(LPVOID IocpHandle)
{
    DWORD dwRecv=0;
    DWORD dwFlags=0;
    
    HANDLE hIocp=reinterpret_cast<HANDLE>(IocpHandle);
    DWORD dwTransCount=0;
    PPRE_IO_DATA pPreIoData=NULL;
    PPRE_SOCKET_DATA pPreHandleData=NULL;

16.
嫁给程序员,或许一辈子没机会开Pagani、坐Lamborghi,却也会听到他在梦中叹道:“倘若宾利Chrysler也能盗版就好了……”

当发送操作达成时,线程池中的3个劳重力线程池激活,它倒闭连接(HTTP协议),然后处理其余的IO操作结果,要是没有其余的东西须求处理时重回线程池等待.

15.
嫁给弱者的程序员,只怕永远不能够目睹他像李阳中那样以一敌十的仪表堂堂,却也会听到他吼道:“哪个孙子又在QQ上骂你啦?看本人不盗了她的号……”

当多个客户机ClientA连接来时主程序投递三个重叠读操作,然后等待下2个客户机连接,当读操作达成时ThreadA被激活,它接受多个HTTP
GET命令,然后ThreadA使用重叠写操作发送1个网页给ClientA,然后立刻重回线程池等待处理下2个IO操作结果,那时发送操作还未曾马到成功,
又有二个客户机ClientB连接来,主程序再投递3个重叠读操作,当读操作实现时ThreadA(当然也只怕是ThreadB)再次被激活,它再也同一
步骤,收到两个GET命令,使用重叠写操作发送叁个网页给ClientB,此次它并今后得及回到线程池时,又有二个连接ClientC连入,主程序再投递
三个交汇读操作,读操作完结时ThreadB被激活(因为ThreadA还未曾回来线程池)它接受一个HTTP
GET命令,然后ThreadB使用重叠写操作发送二个网页给ClientC,然后ThreadB回到线程池,那时ThreadA也回到了线程池.

8.
亮堂系统若有难点维护就无法保全平稳运维,所以一定会天天都对老婆精心呵护。

想想一下什么的模子能够让三个线程为多少个客户端服务吗!那就要跳出每来一个连连启线程为其服务的原则性思维方式,大家把线程服务的小不点儿单元区划为单
独的读或写操作(注意是读或写不是读和写),而不是3个客户端从一连到断开时期的兼具读写操作.每一个线程都选拔重叠IO进行读写操作,投递了读写请求后线
程回到线程池,等待为别的客户机服务,当操作完结或出错开上下班时间再回去处理操作结果,然后再回去线程池.

7.
清楚既然世界上不设有尚未Bug的次第,就一发不会有没有缺点的人,所以绝不会老婆太过苛求。

你能够这么认为重叠IO,现在您早就跻身二个服务器/客户机环境,请不要混淆概念,那里的服务器是指操作系统,而客户机是指你的先后(它进行IO操
作),是当您举行IO操作(send,recv,writefile,readfile….)时你发送三个IO请求给服务器(操作系统),由服务器来
达成你需求的操作,然后你怎么着事都未曾了,当服务器达成IO请求时它会公告你,当然在那时期你能够做其余交事务,3个常用的技能是在发送重叠IO请求后,程序
在三个循环中三只调用PeekMessage,TranslateMessage和DispatchMessage更新界面,同时调用
GetOverlappedResult等待服务器落成IO操作,更敏捷一点的做法是使用IO达成例程来处理服务器(操作系统)再次来到的结果,但并不是各样援救重叠IO操作的函数都辅助达成例程如TransmitFile函数.

 

当读操作实现时一个线程池中的贰个劳力线程被激活取得了操作结果,处理GET或POST命令,然后发送几个网页内容,发送也是一个重合操作,然后
处理对此外客户机的IO操作结果,假若没有其他的东西供给处理时再次来到线程池等待.能够见到使用那种模型发送和吸纳能够是也得以不是二个线程.

  1. 平常总加班.

例4.主程序:
1.开贰个线程池,里面有机器能承受的最大线程数个线程,线程都处于挂起(suspend)状态
1.监听二个端口
2.等候连接
3.当有连接来时
4.从线程池里Resume2个线程对这么些客户端进行拍卖
5.回到2

  1. 不饮酒不发脾性!

例3.主程序:
1.监听一个端口
2.守候连接
3.当有连接来时
4.启贰个线程对那些客户端进行处理
5.回到2

17.
对色彩和流行毫无感觉。所以当内人从试衣间里走出去的时候,他会故作沉思状地摸摸下巴,然后轻易从数组[“很讨人喜欢”,”显得你更高挑了”,”显得你更文明了”,”哇,好性感!”,”好像不太相符你如此瘦的小妞”,”好清纯!”,”那颜色最符合您那样肌肤好的丫头了”,”天哪,穿在您身上就是分化等!”]中精选二个Item。

劳动线程:
1.读客户端请求
2.比方客户端不再有请求,执行6
3.拍卖请求
4.再次回到操作结果
5.回到1
6.脱离线程

6.
只认识0和1,基本没理财能力,一定会主动把具有的钱都付出妻子管,还会千恩万谢地。

如果以往系统中有三个线程,ThreadA,ThreadB它们在都等拍卖二回重合IO操作的形成结果

12.
一旦今后儿童不爱念书,内人就足以感化他说:“再不用功,将来就会像你老爹那样,只可以作程序员……”

首先.做为完毕端口的功底,我们应该清楚重叠IO,这亟需您曾经知道了基础对象及操作系统的局地概念概念,什么是信号/非信号态,什么是伺机函
数,什么是打响等待的副作用,什么是线程挂起等,假设那一个概令还尚无通晓,你应超越看一下Windows
宗旨编制程序中的相关内容.固然已经知晓那个,那么重叠IO对你的话并简单.

13.
比方今后孩子沉迷网游,内人就足以埋汰他说:“你还在玩你老爸在厕所里憋出来的十分破游戏呐?”

    hIocp=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0);

  1. 没时直接触任何Girl,想搞婚外恋也没可能。

    for(;i<gSockDataVec.size();i++)
    {
        PPRE_SOCKET_DATA pSockData=gSockDataVec[i];
        closesocket(pSockData->hSocket);
        delete pSockData;
    }

11.
老婆的QQ倒霉用了,急得不得了。程序员会从容地说:“没事,交给笔者啊”,然后祭出SoftIce、WinDbg、VisualStidio
20XX调节3时辰,最终搞到系统崩溃,重装了事。

假诺那是二个WEB服务器程序,能够见到工我线程是以读或写为最小的劳作单元运转的,在主程序里面实行了三遍重合读操作

  1. 每天都读书到中午,是男女的好规范。

探望那样的服务器模型:
例5.主程序:
1.开多少个线程池,里面有机器内CPU个数两倍的线程,线程都处在挂起(suspend)状态,它们在都等处理3次重合IO操作的做到结果
1.监听二个端口
2.等候连接
3.当有连接来时
4.投递多少个交汇读操作读取命令
5.回到2

  1. 悉心的心,除了电脑就是你!

typedef vector<PPRE_SOCKET_DATA>    SocketDataVector;
typedef vector<PPRE_IO_DATA>        IoDataVector;

例2.三回重合写操作进度(完结例程方法):
1.填写二个OVE奥德赛LAPPED结构
2.展开3遍写操作,并点名重叠操作参数(上边的OVE帕杰罗LAPPED结构变量的指针),并钦赐达成例程
3.做此外交事务(如更新界面)
4.当成功例程被调用表明IO操作已经做到或出错,今后能够对操作结果进行拍卖了

                EnterCriticalSection(&csProtection);
                    IoDataVector::iterator
itrIoDelete=find(gIoDataVec.begin(),gIoDataVec.end(),pPreIoData);
                    SocketDataVector::iterator
itrSockDelete=find(gSockDataVec.begin(),gSockDataVec.end(),pPreHandleData);
                   delete *itrIoDelete;
                   delete *itrSockDelete;
                   gIoDataVec.erase(itrIoDelete);
                   gSockDataVec.erase(itrSockDelete);
                LeaveCriticalSection(&csProtection);

typedef struct
{
    SOCKET hSocket;
    SOCKADDR_IN ClientAddr;
}PRE_SOCKET_DATA,*PPRE_SOCKET_DATA;

            case IoRecv:
                cout<<“Client:”
                    <<inet_ntoa(pPreHandleData->ClientAddr.sin_addr)
                    <<“:”<<ntohs(pPreHandleData->ClientAddr.sin_port)
                    <<” recv finished”<<endl;
                pPreIoData->IoType=IoSend;
                
                if(!TransFile(pPreIoData,pPreHandleData,dwTransCount))
                {
                    memset(&pPreIoData->oa,0,sizeof(OVERLAPPED));
                    strcpy(pPreIoData->DataBuf.buf,”File transmit
error!/r/n”);
                    pPreIoData->DataBuf.len=strlen(pPreIoData->DataBuf.buf);
                    
                    WSASend(pPreHandleData->hSocket,&pPreIoData->DataBuf,1,
                        &dwRecv,dwFlags,
                        reinterpret_cast<LPWSAOVERLAPPED>(pPreIoData),NULL);
                }
                break;
                
            case IoQuit:
                goto LQUIT;
                
            default:
                ;
            }
        }    
    }
    
LQUIT:
    return 0;
}

    InitializeCriticalSection(&csProtection);
    SetUnhandledExceptionFilter(MyExceptionFilter);
    SetConsoleCtrlHandler(ShutdownHandler,TRUE);

对于状态机概念,在不可计数方面都接纳,TCPIP中有,编写翻译原理中有,OpengGL中有等等,笔者的离散数学糟糕(小编是会计专业不学这几个),可是还是搞懂了些,笔者想假使你多花些时间看,如故得以搞懂的.最后是三个粗略的文件传输服务器程序代码,只用了三个线程(小编的机器里唯有一块CPU)就足以服务多个客户端.我调节和测试时用它同时为陆个nc客户端提供文件下载服务都并未难点,当然越多也不会有标题,只是略为使用了一下NT
5的线程池和成功端口技术就足以有如此高的特性,更不要说IIS的性格咯!

BOOL WINAPI ShutdownHandler(DWORD dwCtrlType)
{
    PRE_SOCKET_DATA PreSockData={0};
    PRE_IO_DATA PreIoData={0};

using namespace std;

参考资料:
《MSDN 2001》
《Windows 互连网编制程序》
《Windows 大旨编程》
《TCP/IP详解》

微软的IIS
WEB服务器就是应用那样的服务端模型,很两人说怎么阿帕奇服务器比IIS的品质好什么怎么的本身代表猜疑,除非阿帕奇服务器能够将线程分割成,为更小的单
元服务,作者觉着不太恐怕!这种成功端口模型已经将单个读或写操作作为最小的劳务单元,小编以为在一如既往机器配置的景观下IIS的品质要远远不止别的WEB服务
器,这也是从完结机理上来分析的,假使出现性能上的歧异或然是在不相同的操作系统上,也许Linux的基石比Windows的和睦,有人真正商量过呢?依旧我们一起在炒作啊.

#define _WIN32_WINNT    0x0500

                       
                continue;
            }
            
            switch(pPreIoData->IoType){
            case IoTransFile:
                cout<<“Client:”
                    <<inet_ntoa(pPreHandleData->ClientAddr.sin_addr)
                    <<“:”<<ntohs(pPreHandleData->ClientAddr.sin_port)
                    <<” Transmit finished”<<endl;
                CloseHandle(*reinterpret_cast<HANDLE*>(pPreIoData->Buffer));
                goto LRERECV;
                
            case IoSend:
                cout<<“Client:”
                    <<inet_ntoa(pPreHandleData->ClientAddr.sin_addr)
                    <<“:”<<ntohs(pPreHandleData->ClientAddr.sin_port)
                    <<” Send finished”<<endl;

            if(pPreIoData)
            {
                EnterCriticalSection(&csProtection);
                    gSockDataVec.push_back(pPreHandleData);
                    gIoDataVec.push_back(pPreIoData);
                LeaveCriticalSection(&csProtection);

例1.三次重合写操作进程(GetOverlappedResult方法):
1.填写1个OVEXC90LAPPED结构
2.拓展三回写操作,并钦命重叠操作参数(上边的OVEEvoqueLAPPED结构变量的指针)
3.做别的交事务(如更新界面)
4.GetOverlappedResult取操作结果
5.要是IO请求没有完结,并且没有出错则赶回期3
6.甩卖IO操作结果

HANDLE hIocp=NULL;
SOCKET hListen=NULL;

    PreIoData.IoType=IoQuit;

一旦您早就通晓地点的定义,就曾经很接近IO实现端口了,当然那只是很正规的交汇操作它已经卓殊急速,但假设再组成十二线程对3个File或
是Socket实行重叠IO操作就会分外复杂,日常程序员很难把握那种复杂度.完结端口能够说即是为了丰裕发挥多线程和重叠IO操作相结合的质量而设计
的.很多少人都说它复杂,其实只要您自个儿完毕一个八线程的对多个File或是Socket举办重叠IO操作的次第(注意是四个线程对一个HANDLE或
SOCKET举办重叠IO操作,而不是启一个线程对3个HANDLE进行重叠IO操作)就会发觉形成端口实际上简化了多线程里应用重叠IO的复杂度,并且
品质更高,品质高在哪?上边举办表明.

咱俩或许写过如此的服务端程序:

当对ClientA的重合写操作已经完毕,ThreadA(也足以是ThreadB)又被激活它倒闭与ClientA连接,但还并未回来线程池,与
此同时发送给ClientB的重合写操作也形成,ThreadB被激活(因为ThreadA还一贯不回到线程池)它倒闭与ClientB的连接,然后重回线
程池,那时ClientC的写操作也完结,ThreadB再一次被激活(因为ThreadA依旧不曾回去线程池),它再关闭与ClientC的连天,这时
ThreadA回到线程池,ThreadB也回到线程池.那时对多个客户端的服务整个达成.能够看看在整整服务进度中,”建立连接”,”读数据”,”写数
据”和”关闭连接”等操作是逻辑上接连而实在分开的.

    SYSTEM_INFO si={0};
    GetSystemInfo(&si);
    si.dwNumberOfProcessors<<=1;

CRITICAL_SECTION    csProtection;

                memset(pPreIoData,0,sizeof(PRE_IO_DATA));
                pPreIoData->IoType=IoRecv;
                pPreIoData->DataBuf.len=MAX_BUFFER_SIZE;
                pPreIoData->DataBuf.buf=pPreIoData->Buffer;
                DWORD dwRecv=0;
                DWORD dwFlags=0;
                WSARecv(hAccept,&pPreIoData->DataBuf,1,
                    &dwRecv,&dwFlags,
                    reinterpret_cast<WSAOVERLAPPED*>(pPreIoData),NULL);
            }
            else
            {
                delete pPreHandleData;
                closesocket(hAccept);
            }
        }
    }
    
    return 0;
}

那是一种最简易的互联网服务器模型,大家把它优化一下

/********************************************************************
    created:    2005/12/24
    created:    24:12:2005   20:25
    modified:    2005/12/24
    filename:     d:/vcwork/iocomp/iocomp.cpp
    file path:    d:/vcwork/iocomp
    file base:    iocomp
    file ext:    cpp
    author:        kruglinski(kruglinski_at_gmail_dot_com)
    
    purpose:    利用完毕端口技术完成的高质量文件下载服务程序
*********************************************************************/

    for(i=0;i<gIoDataVec.size();i++)
    {
        PPRE_IO_DATA pIoData=gIoDataVec[i];
        delete pIoData;
    }

LRERECV:
                pPreIoData->IoType=IoRecv;
                pPreIoData->DataBuf.len=MAX_BUFFER_SIZE;
                memset(&pPreIoData->oa,0,sizeof(OVERLAPPED));

劳动线程:
1.比方读完毕,则处理读取的内容(如HTTP GET命令),不然执行3
2.投递1个重叠写操作(如重回HTTP GET命令须求的网页)
3.比方是二个写操作实现,能够再投递五个交汇读操作,读取客户机的下三个请求,只怕是关闭连接(如HTTP协议里每发完三个网页就断开)
4.得到下三个交汇IO操作结果,要是IO操作未能如愿或没有IO操作则回到线程池

                WSARecv(pPreHandleData->hSocket,&pPreIoData->DataBuf,1,
                    &dwRecv,&dwFlags,
                    reinterpret_cast<LPWSAOVERLAPPED>(pPreIoData),NULL);

 

能够设想现在有多个挂起的出殡和埋葬操作分别是ThreadA发送给ClientA和ClientB的网页,以及ThreadB发送给ClientC的网页,它们由操作系统内核来处理.ThreadA和ThreadB以往早就回来线程池,能够继承为任何任何客户端服务.

        cout<<“Shutdown at
“<<TimeNow()<<endl<<“wait for a moment
please”<<endl;
        
        //让出CPU时间,让线程退出
        for(int t=0;t<80;t+=1)
        {
            Sleep(PRE_DOT_TIMER);
            cout<<“.”;
        }
        
        CloseHandle(hIocp);
    }
    
    int i=0;

LONG WINAPI MyExceptionFilter(struct _EXCEPTION_POINTERS
*ExceptionInfo)
{
    ShutdownHandler(0);
    return EXCEPTION_EXECUTE_HANDLER;
}

    hListen=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(INVALID_SOCKET==hListen)
    {
        ShutdownHandler(0);
    }
    
    SOCKADDR_IN addr={0};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(DefPort);
    
    if(bind(hListen,reinterpret_cast<PSOCKADDR>(&addr),
        sizeof(addr))==SOCKET_ERROR)
    {
        ShutdownHandler(0);
    }
    
    if(listen(hListen,256)==SOCKET_ERROR)
        ShutdownHandler(0);

http://blog.csdn.net/tjb\_1216/article/details/4628971

到前天达成七个线程处理了三遍读操作和三次写操作,在那一个读写操作进度中所出现的状态机(state
machine)是比较复杂的,我们模拟的是由此小编简化过的,实际上的情景要比这么些还要复杂很多,可是那样的服务端模型在客户端请求越来越多时与前八个模型相比的属性越高.而选取到位端口我们得以很简单实现如此的服务器模型.

瞩望我们不用陷在那几个顺序的框架中,Ctrl+C,Ctrl+V没有怎么意义,要理解它的实质.程序采取Visual
C++ 6.0 SP5+二〇〇〇 Platform SDK编写翻译通过,在Windows XP
Professional下调节和测试运转通过.程序运维的最低供给是Windows 两千操作系统.

SocketDataVector    gSockDataVec;
IoDataVector        gIoDataVec;

                break;

劳务线程与例3模型里的一样,只是当线程处理完客户端全部请求后,不是脱离而是重回线程池,再次挂起让出CPU时间,并等候为下1个客户机服务.当
然在此时期线程会因为IO操作(服务线程的第3,5操作,可能还有任何阻塞操作)挂起协调,但不会重临线程池,也正是说它3次只可以为2个客户端服务.

那或然是你能想到的最急忙的服务端模型了呢!它与第二个服务端模型对照少了成千上万个用户态到内核态的CONTEXT
Switch,反映也愈加急迅,可能你大概觉得这很无所谓,这表达您缺乏对周边高品质服务器程序(比如网游服务端)的认识,尽管您的服务端程序要对几
千万个客户端实行劳动吗?那也是微软Windows NT开发组在NT
5以上的系统中添加线程池的原因.

    while(TRUE)
    {
        if(GetQueuedCompletionStatus(hIocp,&dwTransCount,
            reinterpret_cast<LPDWORD>(&pPreHandleData),
            reinterpret_cast<LPOVERLAPPED*>(&pPreIoData),INFINITE))
        {
            if(0==dwTransCount&&IoQuit!=pPreIoData->IoType)
            {
                cout<<“Client:”
                    <<inet_ntoa(pPreHandleData->ClientAddr.sin_addr)
                    <<“:”<<ntohs(pPreHandleData->ClientAddr.sin_port)
                    <<” is closed”<<endl;

int main(int argc,char **argv)
{
    if(argc==2)
        DefPort=atoi(argv[1]);

    WSADATA data={0};
    WSAStartup(0x0202,&data);

原稿出处:http://blog.csdn[.NET](http://lib.csdn.net/base/dotnet)/roen/archive/2007/03/19/1533378.aspx

typedef enum{IoTransFile,IoSend,IoRecv,IoQuit} IO_TYPE;

    while(TRUE)
    {
        int namelen=sizeof(addr);
        memset(&addr,0,sizeof(addr));
        SOCKET
hAccept=accept(hListen,reinterpret_cast<PSOCKADDR>(&addr),&namelen);

探访在那样的模型中3个线程怎么为多个客户端服务,同样是人云亦云三个WEB服务器例子:

 

#i nclude <cstdlib>
#i nclude <clocale>
#i nclude <ctime>
#i nclude <iostream>//一运用输入输出流程序立刻增大70K
#i nclude <vector>
#i nclude <algorithm>
#i nclude <winsock2.h>
#i nclude <mswsock.h>

    WSACleanup();
    exit(0);
    return TRUE;
}

    
以1个文件传输服务端为例,在小编的机器上它只起多个线程就能够为无数个客户端同时提供文件下载服务,程序的性质会随机器内CPU个数的增多而线性增加,我尽恐怕做到使它清晰易懂,即便先后非常小却用到了NT
5的一对新天性,重叠IO,实现端口以及线程池,基于那种模型的服务端程序应该是NT系统上品质最佳的了.

                closesocket(pPreHandleData->hSocket);

const int MAX_BUFFER_SIZE=1024;
const int PRE_SEND_SIZE=1024;
const int QUIT_TIME_OUT=3000;
const int PRE_DOT_TIMER=QUIT_TIME_OUT/80;

            PPRE_SOCKET_DATA pPreHandleData=new PRE_SOCKET_DATA;
            pPreHandleData->hSocket=hAccept;
            memcpy(&pPreHandleData->ClientAddr,&addr,sizeof(addr));
            
            CreateIoCompletionPort(reinterpret_cast<HANDLE>(hAccept),
                hIocp,reinterpret_cast<DWORD>(pPreHandleData),0);
            
            PPRE_IO_DATA pPreIoData=new(nothrow) PRE_IO_DATA; 

u_short DefPort=8182;

        if(hAccept!=INVALID_SOCKET)
        {
            cout<<“accept a
client:”<<inet_ntoa(addr.sin_addr)<<“:”<<ntohs(addr.sin_port)<<endl;

    for(int i=0;i<si.dwNumberOfProcessors;i++)
    {
        
        QueueUserWorkItem(ThreadProc,hIocp,WT_EXECUTELONGFUNCTION);
    }
    
    cout<<“Startup at “<<TimeNow()<<endl
        <<“work on port “<<DefPort<<endl
        <<“press CTRL+C to
shutdown”<<endl<<endl<<endl;

    DeleteCriticalSection(&csProtection);
    if(hListen)
        closesocket(hListen);

typedef struct
{
    OVERLAPPED    oa;
    WSABUF        DataBuf;
    char        Buffer[MAX_BUFFER_SIZE];
    IO_TYPE        IoType;
}PRE_IO_DATA,*PPRE_IO_DATA;

发表评论

电子邮件地址不会被公开。 必填项已用*标注