美高梅娱乐4858.com成就端口与高性能服务器程序开发

出品各类型之间的涉嫌**

综观国内互联网跟运动互联网的发展史,以及各个产品类型的商海格局,媒体型产品,排名靠前之是腾讯、新浪、搜狐和网易四深门户。工具型产品,如下载工具:迅雷、快车市场份额领先;影音播放工具:暴风影音占据统治地位;搜索引擎:百度占据绝对的执政地位。社区类产品,排名靠前的是腾讯、人人、新浪、开心。平台型产品遭,阿里巴巴、淘宝、京东百货公司市场份额领先。不难看出,在成品市场布局被占一席之位底店家出品档次是一个动态发展的长河,单一形态的产品类别大都往多独形象的出品类型过渡与前进。下面阐述几种要的活项目过渡与升华的案例。

1.工具+媒体

世家都理解,手机是满足用户沟通和交流需求的工具型产品,同时,手机啊吃叫做第五媒体,本来是沟通工具,后来时有发生矣SP内容,如WAP、彩信、手机报刊杂志等情节,发展成了同等种植新的媒体,而近日几年,手机的App Store发展高效,如iPhone手机的iTunes App
Store、Android手机的Android App
Market等,过渡发展至平台型产品。

世家常见的通器如公交车、地铁、动车、飞机等,它们原来只有是人们从一个地方走到任何一个地方的通畅器,现在大家去探视,公交车、地铁身上起了平面广告和视频广告,动车和飞机都发媒体广告出现,过渡发展到媒体型产品。

工具型产品如果迅雷下载、搜狗输入法、QQ、MSN即时通讯等已一段时间运行时弹出新闻资讯窗口,暴风影音、迅雷看看、PPS影音等原来都是为此来播放视频的工具,拥有新闻资讯、视频等情节后,目前一度搭发展至媒体型产品。

起上述案例不难看出,综合型的工具产品(垂直型工具如Axure原型制作工具,其用户规模颇麻烦遇综合型工具的用户规模)目标用户群规模都死老,有了用户规模与情节后,过渡发展至媒体型产品是正规的样子。

2.社区+平台

社区可分为关系型社区与内容型社区,关系型社区要人人网、开心网等,原先都是应酬网站,为了增强好友之间的交互度,仅指几只温馨研发的社交游戏采用是不行为难落实之,所以出现了面向第三正在使用开发者的开放平台,人人网不仅于互联网及发出开放平台,现在都发展及倒互联网及啊有开放平台,人同人口中间的彼此得冲一定的“载体”,这个载体称为“内容”,包括日记、相册和玩耍等采取,这吗解释了为什么SNS网站要开第三着平台。

内容型社区的出众代表是豆瓣网,豆瓣号称是Web 2.0的标杆网站,它原先是举行书籍、音乐、电影等之上品内容点评的,基于用户一起兴趣爱好的小组,基于兴趣算法的个性化推荐,现在啊开放了阳台,提供了API。

3.工具+平台

奇怪虎360西下发生无数工具型的出品,如360安然无恙警卫、360杀毒、360浏览器等。2011年3月,360有惊无险警卫的用户量超过3亿,成为中华面极充分的安全软件,其用户规模仅次于腾讯的就算经常聊天工具QQ。当起了上亿之用户规模后,推出了360安然无恙桌面,面向第三方开发者的360使用开放平台,这些第三着开发者提供的App可以于平安桌面上展示,也可以当360浏览器上出示,作为上网入口级的采用,从某种程度上说,这种模式吗得称呼基于浏览器的Web App Store。目前如火狐、Chrome等浏览器工具型产品也着为Web App Store开放平台型产品属发展。

4.媒体+工具+社区+平台

初浪以做门媒体起,到新兴的新浪邮箱工具型产品,再后来凡论坛、博客、微博与轻博等社区类产品。从2009年起来,新浪微博表现爆炸式增长,2010年11月,新浪召开首届微博开发者大会,正式推出新浪微博开放平台。微博开放平台为用户提供了海量的微博消息、粉丝关系,以及随时随地发生的信息裂变式传播渠道。

5.平台+社区

阿里巴巴、淘宝是平台型产品,淘江湖是社区项目产品,京东商城平台下啊出京东社区,电商社区化、社区电商化趋势比较明显。2011年12月,阿里巴巴正对平迟迟称为吧“来往”的应酬网络产品进行内测,目前“来往”官网已经上线,不过坐在内测阶段,并不曾对外提供注册入口。阿里巴巴旗下的淘宝网已经相继推出社交产品“淘江湖”、移动社交产品“湖畔”,以及社区产品“淘帮派”,而“来往”是阿里巴巴当走社交圈子的首糟尝试。

6.游戏+社区

盛大以娱乐起家,主营业务是网游。2010年6月8日,盛大网络旗下相互娱乐社区产品“糖果”正式公测。“糖果”是平缓缓“融合开放平台+类微博”的制品,主要是做盛大旗下的玩乐、文学、视频等各种娱乐资源。盛大推社区一方面可以吧海下嬉戏、视频、文学等事务提供新的营销平台,另一方面,也得增强用户黏性,弥补网游用户的消散。

搜狐畅游:《天龙八部》+畅游网。《天龙八部》加入过多SNS元素,比如,可以翻好友动态、分享、组团打怪、虚拟结婚、拜师收徒等。畅游网是搜狐畅游“网游社区化”的第一独尝试。这是首先个与《天龙八部》游戏互动结合的社区产品,目前夫情以及架构和主流SNS基本相同,可提供仓储和分享、日记记录以及分享、短消息、星座速配、投票、休闲游戏等功用。

游戏社区化、社区游戏化趋势比较明确。

7.工具+社区+游戏+媒体+平台

工具到社区、游戏、媒体和平台的一流代表尽管是腾讯,腾讯的制品系统如下。

(1)工具型产品:QQ即经常通信、TT浏览器、QQ医生、QQ旋风、搜搜、QQ音乐、QQ拼音输入法、QQ词典等。

(2)社区类型产品:QQ空间、腾讯朋友、腾讯微博等。

(3)游戏型产品:QQ游戏、3366、网游等。

(4)媒体型产品:腾讯网、腾讯视频等。

(5)平台型产品:电商平台拍拍网、腾讯的财付通开放平台、社区开放平台、Web QQ开放平台、Q+开放平台等。

 美高梅娱乐4858.com 1

本文节选自《神一样的产品经营——基于移动及互联网产品实行》一书

闫荣
编著

电子工业出版社出版

书详细信息:

http://www.cnblogs.com/broadview/archive/2012/07/17/2595491.html

参考资料:
《MSDN 2001》
《Windows 网络编程》
《Windows 核心编程》
《TCP/IP详解》

条例2.同不行重合写操作过程(完成例程方法):
1.填写一个OVERLAPPED结构
2.进行同样涂鸦写操作,并点名重叠操作参数(上面的OVERLAPPED结构变量的指针),并点名完成例程
3.召开其他事(如更新界面)
4.当成功例程被调用说明IO操作都完结或错,现在得本着操作结果进行拍卖了

我们恐怕勾过这么的服务端程序:

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

    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;

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;

立即是均等种最简便易行的网络服务器模型,我们拿它们优化一下

                break;

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

            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; 

当下或者是您能体悟的最好迅速的服务端模型了咔嚓!它跟第一个服务端模型对照少了无数单用户态到外核态的CONTEXT
Switch,反映为尤为快捷,也许你恐怕认为这很无所谓,这证明你缺乏针对广阔高性能服务器程序(比如网游服务端)的认识,如果你的服务端程序一旦本着几
千万个客户端进行劳动吗?这也是微软Windows NT开发组在NT
5以上的体系受到补充加线程池的原因.

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.均等次等重合写操作过程(GetOverlappedResult方法):
1.填写一个OVERLAPPED结构
2.开展同样坏写操作,并点名重叠操作参数(上面的OVERLAPPED结构变量的指针)
3.做其他事(如更新界面)
4.GetOverlappedResult取操作结果
5.如果IO请求没有就,并且没有错则归期3
6.甩卖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);

首先.做啊好端口的根基,我们相应明白重叠IO,这亟需而曾明白了根本对象和操作系统的有的定义概念,什么是信号/非信号态,什么是待函
数,什么是打响等待的副作用,什么是线程挂于等,如果这些概令还尚无明了,你应有先押一下Windows
核心编程中的连锁内容.如果已经了解这些,那么重叠IO对你的话并无难.

劳线程:
1.而念好,则处理读取的始末(如HTTP GET命令),否则执行3
2.投递一个重合写操作(如归HTTP GET命令需要之网页)
3.比方是一个形容操作完,可以重投递一个重合读操作,读取客户机的下一个呼吁,或者是关闭连接(如HTTP协议里各级发为止一个网页就断开)
4.拿走下一个交汇IO操作结果,如果IO操作没有得或者没有IO操作则回到线程池

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

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

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

    return bRet;
}

 

HANDLE hIocp=NULL;
SOCKET hListen=NULL;

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

当对ClientA的层写操作都就,ThreadA(也得以是ThreadB)又给激活它倒闭及ClientA连接,但尚从未返回线程池,与
此同时发送给ClientB的叠写操作也完了,ThreadB被激活(因为ThreadA还尚无回线程池)它倒闭与ClientB的连接,然后回来线
程池,这时ClientC的描摹操作为就,ThreadB再次为激活(因为ThreadA还是无回去线程池),它再也关闭及ClientC的连日,这时
ThreadA回到线程池,ThreadB也归线程池.这时对三个客户端的服务全完成.可以看到在周服务过程遭到,”建立连接”,”读数据”,”写数
据”和”关闭连接”等操作是逻辑上一连而其实分开的.

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

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

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

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

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

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

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

当发送操作完成时,线程池中之一个劳动力线程池激活,它倒闭连接(HTTP协议),然后处理任何的IO操作结果,如果没另外的物要处理时返回线程池等待.

CRITICAL_SECTION    csProtection;

微软的IIS
WEB服务器即是利用这样的服务端模型,很多口说啊阿帕奇服务器比IIS的性能好啊什么的本人代表难以置信,除非阿帕奇服务器得以用线程分割成,为再有些之单
元服务,我当不太可能!这种好端口模型都将单个读或写操作作为最小之服务单元,我看以平机器配置的状态下IIS的属性要远远超乎其他WEB服务
器,这为是自落实机理上来分析的,如果出现性能达到的差别可能是以不同之操作系统及,也许Linux的根本比Windows的温馨,有人真正研究过为?还是
大家一起以炒作啊.

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

    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;

于状态机概念,在许多者都以,TCPIP中发出,编译原理中发出,OpengGL中生出等等,我之离散数学不好(我是会计专业不学是),不过要
搞懂了来,我怀念如果您基本上花些时日看,还是得打明白的.最后是一个简易的文件传输服务器程序代码,只所以了点滴单线程(我之机械里就出同样片CPU)就可服务多
个客户端.我调试时用它同时为6单nc客户端提供文件下充斥服务还未曾问题,当然更多也未会见来问题,只是稍微为以了一晃NT
5之线程池和成功端口技术就得生如此高的特性,更不用说IIS的属性咯!

当一个客户机ClientA连接来时主程序投递一个层读操作,然后等待下一个客户机连接,当读操作完时ThreadA被激活,它接受一个
HTTP
GET命令,然后ThreadA使用重叠写操作发送一个网页为ClientA,然后立即赶回线程池等待处理下一个IO操作结果,这时发送操作还从来不完,
又闹一个客户机ClientB连接来,主程序再投递一个叠读操作,当读操作就时ThreadA(当然也说不定是ThreadB)再次给激活,它再相同
步骤,收到一个GET命令,使用重叠写操作发送一个网页为ClientB,这次她并未来得及回到线程池时,又生出一个连接ClientC连入,主程序再投递
一个交汇读操作,读操作完时ThreadB被激活(因为ThreadA还没返回线程池)它接受一个HTTP
GET命令,然后ThreadB使用重叠写操作发送一个网页为ClientC,然后ThreadB回到线程池,这时ThreadA也回了线程池.

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

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

                       
                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;

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

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

SocketDataVector    gSockDataVec;
IoDataVector        gIoDataVec;

当读操作完时一个线程池中之一个劳动力线程被激活取得了操作结果,处理GET或POST命令,然后发送一个网页内容,发送也是一个层操作,然后
处理对其它客户机的IO操作结果,如果无其余的东西用处理常回来线程池等待.可以看出运这种模型发送和接好是啊可免是一个线程.

u_short DefPort=8182;

/********************************************************************
    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:    利用好端口技术实现之强性能文件下充斥服务程序
*********************************************************************/

探这样的服务器模型:
例5.主程序:
1.开一个线程池,里面有机器内CPU个数鲜加倍之线程,线程都处于挂于(suspend)状态,它们在还当处理同坏重合IO操作的做到结果
1.监听一个端口
2.等候连接
3.当起连接来时
4.投递一个叠读操作读取命令
5.回到2

            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;
}

考虑一下什么的范可以于一个线程为多单客户端服务吗!那即便设跳出每来一个老是启线程为那劳动的固定思维模式,我们将线程服务之顶小单元区划为单
独的诵读或摹写操作(注意是朗诵或写不是读与描写),而无是一个客户端起连续到断开期间的兼具读写操作.每个线程都以重叠IO进行读写操作,投递了读写请求后线
程回到线程池,等待也另外客户机服务,当操作就或者错时更回到处理操作结果,然后再返回线程池.

 

例4.主程序:
1.开一个线程池,里面有机器能经受的极致特别线程数个线程,线程都地处挂于(suspend)状态
1.监听一个端口
2.候连接
3.当起连接来时
4.由线程池里Resume一个线程对斯客户端进行处理
5.回到2

    
以一个文件传输服务端为条例,在本人的机器及它们只于片单线程就可以吗博只客户端同时提供文件下充斥服务,程序的性质会照机器内CPU个数的加而线性增长,我
尽可能做到使她清晰易懂,虽然先后非常有点也用到了NT
5的局部初特色,重叠IO,完成端口与线程池,基于这种模型的服务端程序应该是NT系统及性最好好的了.

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

设若现在系面临生点儿单线程,ThreadA,ThreadB它们于犹抵处理同坏重合IO操作的好结果

好想象现在发三独挂于的发送操作分别是ThreadA发送给ClientA和ClientB的网页,以及ThreadB发送给ClientC的网页,它们由操作系统内核来处理.ThreadA和ThreadB现在早已回线程池,可以继承为外任何客户端服务.

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;

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

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

及现在为止两只线程处理了三涂鸦读操作及老三次等写操作,在这些读写操作过程遭到所出现的状态机(state
machine)是比较复杂的,我们学的是透过自家简化过的,实际上的状态而于之还要复杂很多,然而这么的服务端模型在客户端请求越多时与前方少独模型相
比的习性更是高.而以完端口我们可以好容易实现这样的服务器模型.

省在如此的范中一个线程怎么呢多单客户端服务,同样是效仿一个WEB服务器例子:

    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;

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

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

                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;
}

苟您已经亮地方的定义,就曾很类似IO完成端口了,当然就不过是蛮正常的层操作它们就挺快,但倘若重新成多线程对一个File或
是Socket进行重叠IO操作就会见非常复杂,通常程序员很为难把这种复杂度.完成端口可以说即使是为充分发挥多线程和重叠IO操作相结合的特性而设计
的.很多人还说她复杂,其实如果您协调实现一个差不多线程的对准一个File或是Socket进行重叠IO操作的次(注意是基本上单线程对一个HANDLE或
SOCKET进行重叠IO操作,而不是从头一个线程对一个HANDLE进行重叠IO操作)就会见发现就端口实际上简化了多线程里采取重叠IO的复杂度,并且
性能再胜似,性能大在哪?下面进行说明.

期望大家不用陷在是序的框架中,Ctrl+C,Ctrl+V没有什么意义,要理解她的实质.程序用Visual
C++ 6.0 SP5+2003 Platform SDK编译通过,在Windows XP
Professional下调试运行通过.程序运行的最低要求凡Windows 2000操作系统.

using namespace std;

        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;

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

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

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

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

假若这是一个WEB服务器程序,可以见见工作者线程是盖朗诵或写啊最小之干活单元运行的,在主程序里面进行了相同次重合读操作

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;

    PreIoData.IoType=IoQuit;

#define _WIN32_WINNT    0x0500

劳线程:
1.念客户端请求
2.要是客户端不再来求,执行6
3.甩卖要
4.回操作结果
5.回到1
6.退线程

服务线程与例3模型里之一模一样,只是当线程处理完客户端所有请求后,不是退出而是回到线程池,再次挂于为来CPU时间,并等候也产一个客户机服务.当
然在此期间线程会坐IO操作(服务线程的第1,5操作,也许还时有发生任何阻塞操作)挂于协调,但不会见回来线程池,也就是说它一律软只能为一个客户端服务.

                closesocket(pPreHandleData->hSocket);

若可如此看重叠IO,现在而就进来一个服务器/客户机环境,请不要混淆概念,这里的服务器是乘操作系统,而客户机是恃你的主次(它进行IO操
作),是当您进行IO操作(send,recv,writefile,readfile….)时你发送一个IO请求让服务器(操作系统),由服务器来
完成你要之操作,然后您呀事还尚未了,当服务器就IO请求时她会通知你,当然在即时间若得开另外事,一个常用的技能是在发送重叠IO请求后,程序
在一个循环往复中一头调用PeekMessage,TranslateMessage和DispatchMessage更新界面,同时调用
GetOverlappedResult等待服务器就IO操作,更便捷一点之做法是采用IO完成例程来拍卖服务器(操作系统)返回的结果,但并无是每个
支持重叠IO操作的函数都支持好例程如TransmitFile函数.

发表评论

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