端口技術 GetOverlappedResult [轉(zhuǎn)]

以一個文件傳輸服務端為例,在我的機器上它只起兩個線程就可以為很多個個客戶端同時提供文件下載服務,程序的性能會隨機器內(nèi)CPU個數(shù)的增加而線性增長,我盡可能做到使它清晰易懂,雖然程序很小卻用到了NT 5的一些新特性,重疊IO,完成端口以及線程池,基于這種模型的服務端程序應該是NT系統(tǒng)上性能最好的了.

首先.做為完成端口的基礎,我們應該理解重疊IO,這需要你已經(jīng)理解了內(nèi)核對象及操作系統(tǒng)的一些概念概念,什么是信號/非信號態(tài),什么是等待函數(shù),什么是成功等待的副作用,什么是線程掛起等,如果這些概令還沒有理解,你應該先看一下Windows 核心編程中的相關內(nèi)容.如果已經(jīng)理解這些,那么重疊IO對你來說并不難.

你可以這樣認為重疊IO,現(xiàn)在你已經(jīng)進入一個服務器/客戶機環(huán)境,請不要混淆概念,這里的服務器是指操作系統(tǒng),而客戶機是指你的程序(它進行IO操作),是當你進行IO操作(send,recv,writefile,readfile….)時你發(fā)送一個IO請求給服務器(操作系統(tǒng)),由服務器來完成你需要的操作,然后你什么事都沒有了,當服務器完成IO請求時它會通知你,當然在這期間你可以做任何事,一個常用的技巧是在發(fā)送重疊IO請求后,程序在一個循環(huán)中一邊調(diào)用PeekMessage,TranslateMessage和DispatchMessage更新界面,同時調(diào)用 GetOverlappedResult等待服務器完成IO操作,更高效一點的做法是使用IO完成例程來處理服務器(操作系統(tǒng))返回的結(jié)果,但并不是每個支持重疊IO操作的函數(shù)都支持完成例程如TransmitFile函數(shù).

例1.一次重疊寫操作過程(GetOverlappedResult方法):
1.填寫一個OVERLAPPED結(jié)構(gòu)
2.進行一次寫操作,并指定重疊操作參數(shù)(上面的OVERLAPPED結(jié)構(gòu)變量的指針)
3.做其它事(如更新界面)
4.GetOverlappedResult取操作結(jié)果
5.如果IO請求沒有完成,并且沒有出錯則回到３
6.處理IO操作結(jié)果

例2.一次重疊寫操作過程(完成例程方法):
1.填寫一個OVERLAPPED結(jié)構(gòu)
2.進行一次寫操作,并指定重疊操作參數(shù)(上面的OVERLAPPED結(jié)構(gòu)變量的指針),并指定完成例程
3.做其它事(如更新界面)
4.當完成例程被調(diào)用說明IO操作已經(jīng)完成或出錯,現(xiàn)在可以對操作結(jié)果進行處理了

如果你已經(jīng)理解上面的概念,就已經(jīng)很接近IO完成端口了,當然這只是很常規(guī)的重疊操作它已經(jīng)非常高效,但如果再結(jié)合多線程對一個File或是Socket進行重疊IO操作就會非常復雜,通常程序員很難把握這種復雜度.完成端口可以說就是為了充分發(fā)揮多線程和重疊IO操作相結(jié)合的性能而設計的.很多人都說它復雜,其實如果你自己實現(xiàn)一個多線程的對一個File或是Socket進行重疊IO操作的程序(注意是多個線程對一個HANDLE或SOCKET進行重疊 IO操作,而不是啟一個線程對一個HANDLE進行重疊IO操作)就會發(fā)現(xiàn)完成端口實際上簡化了多線程里使用重疊IO的復雜度,并且性能更高,性能高在哪?下面進行說明.

我們可能寫過這樣的服務端程序:

例3.主程序:
1.監(jiān)聽一個端口
2.等待連接
3.當有連接來時
4.啟一個線程對這個客戶端進行處理
5.回到2

服務線程:
1.讀客戶端請求
2.如果客戶端不再有請求,執(zhí)行6
3.處理請求
4.返回操作結(jié)果
5.回到1
6.退出線程

這是一種最簡單的網(wǎng)絡服務器模型,我們把它優(yōu)化一下

例4.主程序:
1.開一個線程池,里面有機器能承受的最大線程數(shù)個線程,線程都處于掛起(suspend)狀態(tài)
1.監(jiān)聽一個端口
2.等待連接
3.當有連接來時
4.從線程池里Resume一個線程對這個客戶端進行處理
5.回到2

服務線程與例3模型里的相同,只是當線程處理完客戶端所有請求后,不是退出而是回到線程池,再次掛起讓出CPU時間,并等待為下一個客戶機服務.當然在此期間線程會因為IO操作(服務線程的第1,5操作,也許還有其它阻塞操作)掛起自己,但不會回到線程池,也就是說它一次只能為一個客戶端服務.

這可能是你能想到的最高效的服務端模型了吧!它與第一個服務端模型相比少了很多個用戶態(tài)到內(nèi)核態(tài)的CONTEXT Switch,反映也更加快速,也許你可能覺得這很微不足道,這說明你缺少對大規(guī)模高性能服務器程序(比如網(wǎng)游服務端)的認識,如果你的服務端程序要對幾千萬個客戶端進行服務呢?這也是微軟Windows NT開發(fā)組在NT 5以上的系統(tǒng)中添加線程池的原因.

思考一下什么樣的模型可以讓一個線程為多個客戶端服務呢!那就要跳出每來一個連接啟線程為其服務的固定思維模式,我們把線程服務的最小單元分割為單獨的讀或?qū)懖僮?注意是讀或?qū)懖皇亲x和寫),而不是一個客戶端從連接到斷開期間的所有讀寫操作.每個線程都使用重疊IO進行讀寫操作,投遞了讀寫請求后線程回到線程池,等待為其它客戶機服務,當操作完成或出錯時再回來處理操作結(jié)果,然后再回到線程池.

看看這樣的服務器模型:
例5.主程序:
1.開一個線程池,里面有機器內(nèi)CPU個數(shù)兩倍的線程,線程都處于掛起(suspend)狀態(tài),它們在都等處理一次重疊IO操作的完成結(jié)果
1.監(jiān)聽一個端口
2.等待連接
3.當有連接來時
4.投遞一個重疊讀操作讀取命令
5.回到2

服務線程:
1.如果讀完成,則處理讀取的內(nèi)容(如HTTP GET命令),否則執(zhí)行3
2.投遞一個重疊寫操作(如返回HTTP GET命令需要的網(wǎng)頁)
3.如果是一個寫操作完成,可以再投遞一個重疊讀操作,讀取客戶機的下一個請求,或者是關閉連接(如HTTP協(xié)議里每發(fā)完一個網(wǎng)頁就斷開)
4.取得下一個重疊IO操作結(jié)果,如果IO操作沒有完成或沒有IO操作則回到線程池

假設這是一個WEB服務器程序,可以看到工作者線程是以讀或?qū)憺樽钚〉墓ぷ鲉卧\行的,在主程序里面進行了一次重疊讀操作

當讀操作完成時一個線程池中的一個工作者線程被激活取得了操作結(jié)果,處理GET或POST命令,然后發(fā)送一個網(wǎng)頁內(nèi)容,發(fā)送也是一個重疊操作,然后處理對其它客戶機的IO操作結(jié)果,如果沒有其它的東西需要處理時回到線程池等待.可以看到使用這種模型發(fā)送和接收可以是也可以不是一個線程.

當發(fā)送操作完成時,線程池中的一個工作者線程池激活,它關閉連接(HTTP協(xié)議),然后處理其它的IO操作結(jié)果,如果沒有其它的東西需要處理時回到線程池等待.

看看在這樣的模型中一個線程怎么為多個客戶端服務,同樣是模擬一個WEB服務器例子:

假如現(xiàn)在系統(tǒng)中有兩個線程,ThreadA,ThreadB它們在都等處理一次重疊IO操作的完成結(jié)果

當一個客戶機ClientA連接來時主程序投遞一個重疊讀操作,然后等待下一個客戶機連接,當讀操作完成時ThreadA被激活,它收到一個HTTP GET命令,然后ThreadA使用重疊寫操作發(fā)送一個網(wǎng)頁給ClientA,然后立即回到線程池等待處理下一個IO操作結(jié)果,這時發(fā)送操作還沒有完成, 又有一個客戶機ClientB連接來,主程序再投遞一個重疊讀操作,當讀操作完成時ThreadA(當然也可能是ThreadB)再次被激活,它重復同樣步驟,收到一個GET命令,使用重疊寫操作發(fā)送一個網(wǎng)頁給ClientB,這次它沒有來得及回到線程池時,又有一個連接ClientC連入,主程序再投遞一個重疊讀操作,讀操作完成時ThreadB被激活(因為ThreadA還沒有回到線程池)它收到一個HTTP GET命令,然后ThreadB使用重疊寫操作發(fā)送一個網(wǎng)頁給ClientC,然后ThreadB回到線程池,這時ThreadA也回到了線程池.

可以想象現(xiàn)在有三個掛起的發(fā)送操作分別是ThreadA發(fā)送給ClientA和ClientB的網(wǎng)頁,以及ThreadB發(fā)送給ClientC的網(wǎng)頁,它們由操作系統(tǒng)內(nèi)核來處理.ThreadA和ThreadB現(xiàn)在已經(jīng)回到線程池,可以繼續(xù)為其它任何客戶端服務.

當對ClientA的重疊寫操作已經(jīng)完成,ThreadA(也可以是ThreadB)又被激活,它關閉與ClientA連接,但還沒有回到線程池,與此同時發(fā)送給ClientB的重疊寫操作也完成,ThreadB被激活(因為ThreadA還沒有回到線程池)它關閉與ClientB的連接,然后回到線程池, 這時ClientC的寫操作也完成,ThreadB再次被激活(因為ThreadA還是沒有回到線程池),它再關閉與ClientC的連接,這時 ThreadA回到線程池,ThreadB也回到線程池.這時對三個客戶端的服務全部完成.可以看到在整個服務過程中,”建立連接”,”讀數(shù)據(jù)”,”寫數(shù)據(jù)”和”關閉連接”等操作是邏輯上連續(xù)而實際上分開的.

到現(xiàn)在為止兩個線程處理了三次讀操作和三次寫操作,在這些讀寫操作過程中所出現(xiàn)的狀態(tài)機(state machine)是比較復雜的,我們模擬的是經(jīng)過我簡化過的,實際上的狀態(tài)要比這個還要復雜很多,然而這樣的服務端模型在客戶端請求越多時與前兩個模型相比的性能越高.而使用完成端口我們可以很容易實現(xiàn)這樣的服務器模型.

微軟的IIS WEB服務器就是使用這樣的服務端模型,很多人說什么阿帕奇服務器比IIS的性能好什么什么的我表示懷疑,除非阿帕奇服務器可以將線程分割成,為更小的單元服務,我覺得不太可能!這種完成端口模型已經(jīng)將單個讀或?qū)懖僮髯鳛樽钚〉姆諉卧?我覺得在相同機器配置的情況下IIS的性能要遠遠高于其它WEB服務器,這也是從實現(xiàn)機理上來分析的,如果出現(xiàn)性能上的差別可能是在不同的操作系統(tǒng)上,也許Linux的內(nèi)核比Windows的要好,有人真的研究過嗎?還是大家一起在炒作啊.

對于狀態(tài)機概念,在很多方面都用到,TCPIP中有,編譯原理中有,OpengGL中有等等,我的離散數(shù)學不好 (我是會計專業(yè)不學這個),不過還是搞懂了些,我想如果你多花些時間看,還是可以搞懂的.最后是一個簡單的文件傳輸服務器程序代碼,只用了兩個線程(我的機器里只有一塊CPU)就可以服務多個客戶端.我調(diào)試時用它同時為6個nc客戶端提供文件下載服務都沒有問題,當然更多也不會有問題,只是略為使用了一下 NT 5的線程池和完成端口技術就可以有這樣高的性能,更不用說IIS的性能咯!

希望大家不要陷在這個程序的框架中,Ctrl+C, Ctrl+V沒有什么意義,要理解它的實質(zhì).程序使用Visual C++ 6.0 SP5+2003 Platform SDK編譯通過,在Windows XP Professional下調(diào)試運行通過.程序運行的最低要求是Windows 2000操作系統(tǒng).

/**//********************************************************************
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:??? 利用完成端口技術實現(xiàn)的高性能文件下載服務程序
*********************************************************************/

#define _WIN32_WINNT??? 0×0500

#include <cstdlib>
#include <clocale>
#include <ctime>
#include <iostream>//一使用輸入輸出流程序頓時增大70K
#include <vector>
#include <algorithm>
#include <winsock2.h>
#include <mswsock.h>

using namespace std;

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

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;

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

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

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

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

SocketDataVector??? gSockDataVec;
IoDataVector??????? gIoDataVec;

CRITICAL_SECTION??? csProtection;

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

BOOL TransFile(PPRE_IO_DATA pIoData,PPRE_SOCKET_DATA pSocketData,DWORD dwNameLen)
{
//這一句是為nc做的,你可以修改它
pIoData->Buffer[dwNameLen-1]=”;

HANDLE hFile=CreateFile(pIoData->Buffer,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
BOOL bRet=FALSE;

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;

return bRet;
}

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;

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;

closesocket(pPreHandleData->hSocket);

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

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;

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

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

break;

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

HANDLE hIocp=NULL;
SOCKET hListen=NULL;

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

PreIoData.IoType=IoQuit;

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

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;

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

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

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

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

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

u_short DefPort=8182;

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

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

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

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

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

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

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;

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

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

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;

if(pPreIoData)
{
EnterCriticalSection(&csProtection);
gSockDataVec.push_back(pPreHandleData);
gIoDataVec.push_back(pPreIoData);
LeaveCriticalSection(&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;
}

posted on 2008-01-07 16:47 isabc 閱讀(5505) 評論(0)  編輯 收藏 引用 所屬分類: 串口通信