完成連接埠與高效能伺服器程式開發

完成連接埠與高效能伺服器程式開發

Email:kruglinski_at_gmail_dot_com
Blog:kruglinski.blogchina.com

早在兩年前我就已經能很熟練的運用完成連接埠這種技術了,只是一直沒有機會將它用在什麼項目中,這段時間見到這種技術被過分炒作,過分的神秘化,就想寫一篇解釋它如何工作的文章.想告訴大家它沒有傳說中的那麼高深難懂!有什麼錯誤的地方還請高人指正.轉載請註明出處及作者,謝謝!

以一個檔案傳輸服務端為例,在我的機器上它只起兩個線程就可以為很多個用戶端同時提供檔案下載服務,程式的效能會隨機器內CPU個數的增加而線性增長,我儘可能做到使它清晰易懂,雖然程式很小卻用到了NT 5的一些新特性,重疊IO,完成連接埠以及線程池,基於這種模型的服務端程式應該是NT系統上效能最好的了.

首先.做為完成連接埠的基礎,我們應該理解重疊IO,這需要你已經理解了核心對象及作業系統的一些概念概念,什麼是訊號/非訊號態,什麼是等待函數,什麼是成功等待的副作用,什麼是線程掛起等,如果這些概令還沒有理解,你應該先看一下Windows 核心編程中的相關內容.如果已經理解這些,那麼重疊IO對你來說並不難.

你可以這樣認為重疊IO,現在你已經進入一個伺服器/客戶機環境,請不要混淆概念,這裡的伺服器是指作業系統,而客戶機是指你的程式(它進行IO操作),是當你進行IO操作(send,recv,writefile,readfile....)時你發送一個IO請求給伺服器(作業系統),由伺服器來完成你需要的操作,然後你什麼事都沒有了,當伺服器完成IO請求時它會通知你,當然在這期間你可以做任何事,一個常用的技巧是在發送重疊IO請求後,程式在一個迴圈中一邊調用PeekMessage,TranslateMessage和DispatchMessage更新介面,同時調用GetOverlappedResult等待伺服器完成IO操作,更高效一點的做法是使用IO完成常式來處理伺服器(作業系統)返回的結果,但並不是每個支援重疊IO操作的函數都支援完成常式如TransmitFile函數.

例1.一次重疊寫操作過程(GetOverlappedResult方法):
1.填寫一個OVERLAPPED結構
2.進行一次寫操作,並指定重疊巨集指令引數(上面的OVERLAPPED結構變數的指標)
3.做其它事(如更新介面)
4.GetOverlappedResult取操作結果
5.如果IO請求沒有完成,並且沒有出錯則回到期３
6.處理IO操作結果

例2.一次重疊寫操作過程(完成常式方法):
1.填寫一個OVERLAPPED結構
2.進行一次寫操作,並指定重疊巨集指令引數(上面的OVERLAPPED結構變數的指標),並指定完成常式
3.做其它事(如更新介面)
4.當完成常式被調用說明IO操作已經完成或出錯,現在可以對操作結果進行處理了

如果你已經理解上面的概念,就已經很接近IO完成連接埠了,當然這隻是很常規的重疊操作它已經非常高效,但如果再結合多線程對一個File或是Socket進行重疊IO操作就會非常複雜,通常程式員很難把握這種複雜度.完成連接埠可以說就是為了充分發揮多線程和重疊IO操作相結合的效能而設計的.很多人都說它複雜,其實如果你自己實現一個多線程的對一個File或是Socket進行重疊IO操作的程式(注意是多個線程對一個HANDLE或SOCKET進行重疊IO操作,而不是啟一個線程對一個HANDLE進行重疊IO操作)就會發現完成連接埠實際上簡化了多線程裡使用重疊IO的複雜度,並且效能更高,效能高在哪?下面進行說明.

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

例3.主程式:
1.監聽一個連接埠
2.等待串連
3.當有串連來時
4.啟一個線程對這個用戶端進行處理
5.回到2

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

這是一種最簡單的網路伺服器模型,我們把它最佳化一下

例4.主程式:
1.開一個線程池,裡面有機器能承受的最大線程數個線程,線程都處於掛起(suspend)狀態
1.監聽一個連接埠
2.等待串連
3.當有串連來時
4.從線程池裡Resume一個線程對這個用戶端進行處理
5.回到2

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

這可能是你能想到的最高效的服務端模型了吧!它與第一個服務端模型相比少了很多個使用者態到核心態的CONTEXT Switch,反映也更加快速,也許你可能覺得這很微不足道,這說明你缺少對大規模高效能伺服器程式(比如網遊服務端)的認識,如果你的服務端程式要對幾千萬個用戶端進行服務呢?這也是微軟Windows NT開發組在NT 5以上的系統中添加線程池的原因.

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

看看這樣的伺服器模型:
例5.主程式:
1.開一個線程池,裡面有機器內CPU個數兩倍的線程,線程都處於掛起(suspend)狀態,它們在都等處理一次重疊IO操作的完成結果
1.監聽一個連接埠
2.等待串連
3.當有串連來時
4.投遞一個重疊讀操作讀取命令
5.回到2

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

假設這是一個WEB伺服器程式,可以看到工作者線程是以讀或寫為最小的工作單元啟動並執行,在主程式裡面進行了一次重疊讀操作

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

當發送操作完成時,線程池中的一個工作者線程池啟用,它關閉串連(HTTP協議),然後處理其它的IO操作結果,如果沒有其它的東西需要處理時回到線程池等待.

看看在這樣的模型中一個線程怎麼為多個用戶端服務,同樣是類比一個WEB伺服器例子:

假如現在系統中有兩個線程,ThreadA,ThreadB它們在都等處理一次重疊IO操作的完成結果

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

可以想象現在有三個掛起的發送操作分別是ThreadA發送給ClientA和ClientB的網頁,以及ThreadB發送給ClientC的網頁,它們由作業系統核心來處理.ThreadA和ThreadB現在已經回到線程池,可以繼續為其它任何用戶端服務.

當對ClientA的重疊寫操作已經完成,ThreadA(也可以是ThreadB)又被啟用它關閉與ClientA串連,但還沒有回到線程池,與此同時發送給ClientB的重疊寫操作也完成,ThreadB被啟用(因為ThreadA還沒有回到線程池)它關閉與ClientB的串連,然後回到線程池,這時ClientC的寫操作也完成,ThreadB再次被啟用(因為ThreadA還是沒有回到線程池),它再關閉與ClientC的串連,這時ThreadA回到線程池,ThreadB也回到線程池.這時對三個用戶端的服務全部完成.可以看到在整個服務過程中,"建立串連","讀資料","寫資料"和"關閉串連"等操作是邏輯上連續而實際上分開的.

到現在為止兩個線程處理了三次讀操作和三次寫操作,在這些讀寫操作過程中所出現的狀態機器(state machine)是比較複雜的,我們類比的是經過我簡化過的,實際上的狀態要比這個還要複雜很多,然而這樣的服務端模型在用戶端請求越多時與前兩個模型相比的效能越高.而使用完成連接埠我們可以很容易實現這樣的伺服器模型.

微軟的IIS WEB伺服器就是使用這樣的服務端模型,很多人說什麼阿帕奇伺服器比IIS的效能好什麼什麼的我表示懷疑,除非阿帕奇伺服器可以將線程分割成,為更小的單元服務,我覺得不太可能!這種完成連接埠模型已經將單個讀或寫操作作為最小的服務單元,我覺得在相同機器配置的情況下IIS的效能要遠遠高於其它WEB伺服器,這也是從實現機理上來分析的,如果出現效能上的差別可能是在不同的作業系統上,也許Linux的核心比Windows的要好,有人真的研究過嗎?還是大家一起在炒作啊.

對於狀態機器概念,在很多方面都用到,TCPIP中有,編譯原理中有,OpengGL中有等等,我的離散數學不好不過還是搞懂了些,我想如果你多花些時間看,還是可以搞懂的.最後是一個簡單的檔案傳輸伺服器程式碼,只用了兩個線程(我的機器裡只有一塊CPU)就可以服務多個用戶端.我調試時用它同時為6個nc用戶端提供檔案下載服務都沒有問題,當然更多也不會有問題,只是略為使用了一下NT 5的線程池和完成連接埠技術就可以有這樣高的效能,更不用說IIS的效能咯!

希望大家不要陷在這個程式的架構中,Ctrl+C,Ctrl+V沒有什麼意義,要理解它的實質.程式使用Visual C++ 6.0 SP5+2003 Platform SDK編譯通過,在Windows XP Professional下調試運行通過.程式啟動並執行最低要求是Windows 2000作業系統.

/********************************************************************
    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:    利用完成連接埠技術實現的高效能檔案下載服務程式
*********************************************************************/

#define _WIN32_WINNT    0x0500

#include
#include
#include
#include //一使用輸入輸出資料流程式頓時增大70K
#include
#include
#include
#include

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    SocketDataVector;
typedef vector        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]='/0';
    
    HANDLE hFile=CreateFile(pIoData->Buffer,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
    BOOL bRet=FALSE;

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

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

    while(TRUE)
    {
        if(GetQueuedCompletionStatus(hIocp,&dwTransCount,
            reinterpret_cast(&pPreHandleData),
            reinterpret_cast(&pPreIoData),INFINITE))
        {
            if(0==dwTransCount&&IoQuit!=pPreIoData->IoType)
            {
                cout<<"Client:"
                    <ClientAddr.sin_addr)
                    <<":"<ClientAddr.sin_port)
                    <<" is closed"<
                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:"
                    <ClientAddr.sin_addr)
                    <<":"<ClientAddr.sin_port)
                    <<" Transmit finished"<                CloseHandle(*reinterpret_cast(pPreIoData->Buffer));
                goto LRERECV;
                
            case IoSend:
                cout<<"Client:"
                    <ClientAddr.sin_addr)
                    <<":"<ClientAddr.sin_port)
                    <<" Send finished"<
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(pPreIoData),NULL);

                break;

            case IoRecv:
                cout<<"Client:"
                    <ClientAddr.sin_addr)
                    <<":"<ClientAddr.sin_port)
                    <<" recv finished"<                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(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(&PreSockData),
            reinterpret_cast(&PreIoData));

        cout<<"Shutdown at "<        
        //讓出CPU時間,讓線程退出
        for(int t=0;t<80;t+=1)
        {
            Sleep(PRE_DOT_TIMER);
            cout<<".";
        }
        
        CloseHandle(hIocp);
    }
    
    int i=0;

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

    for(i=0;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(0x0202,&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(&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    {
        
        QueueUserWorkItem(ThreadProc,hIocp,WT_EXECUTELONGFUNCTION);
    }
    
    cout<<"Startup at "<        <<"work on port "<        <<"press CTRL+C to shutdown"<
    while(TRUE)
    {
        int namelen=sizeof(addr);
        memset(&addr,0,sizeof(addr));
        SOCKET hAccept=accept(hListen,reinterpret_cast(&addr),&namelen);

        if(hAccept!=INVALID_SOCKET)
        {
            cout<<"accept a client:"<<"<
            PPRE_SOCKET_DATA pPreHandleData=new PRE_SOCKET_DATA;
            pPreHandleData->hSocket=hAccept;
            memcpy(&pPreHandleData->ClientAddr,&addr,sizeof(addr));
            
            CreateIoCompletionPort(reinterpret_cast(hAccept),
                hIocp,reinterpret_cast(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(pPreIoData),NULL);
            }
            else
            {
                delete pPreHandleData;
                closesocket(hAccept);
            }
        }
    }
    
    return 0;
}

參考資料:
《MSDN 2001》
《Windows 網路編程》
《Windows 核心編程》
《TCP/IP詳解》
http://kruglinski.bokee.com/4000210.html