IOCP入门

来源：互联网发布：mac固件密码解锁编辑：程序博客网时间：2024/05/01 20:07

在网络通信中创建一个TCP服务器端通常是这样的：

[cpp] view plaincopy
int nPort =65000;//指定通信端口  
 WSADATA wsaData;  
WSAStartup( MAKEWORD( 2, 2 ), &wsaData );  
  
 // 创建监听套接字，绑定本地端口，开始监听   
 SOCKET sListen = socket( AF_INET,SOCK_STREAM, 0 );  
SOCKADDR_IN addr;   
addr.sin_family = AF_INET;   
addr.sin_port = htons( nPort );   
addr.sin_addr.S_un.S_addr = INADDR_ANY;   
bind( sListen, (sockaddr *)&addr, sizeof( addr ) );   
listen( sListen, 5 );  
  
SOCKADDR_IN saRemote;   
int nRemoteLen = sizeof( saRemote );   
SOCKET sRemote = accept( sListen, (sockaddr *)&saRemote, &nRemoteLen );  

然后线程会挂起，当有客户端连上来时，accept函数会继续往下执行。这时我们就可以调用recv函数接收来自客户端的消息。当考虑到可能有多个客户端连上来时，而每个客户端又要能及时通信。我们通常做法是新开线程来处理。

[cpp] view plaincopy
while(TRUE)  
{  
    sRemote = accept( sListen, (sockaddr *)&saRemote, &nRemoteLen );    
    HANDLE hThread = CreateThread(NULL, 0, ThreadFunc, (void*) sRemote, 0, &dwTreadId); CloseHandle(hThread);    
}  

但如果有大量的客户端连入服务器，新开线程会消耗服务器的大量资源。于是windows提供了一种socket模型来处理这种情况，它就是IOCP，又叫端口完成。它实际上是事先开好N个线程，一个accpet线程和多个工作线程，让它们在那hold[堵塞]。一旦服务器，收到一个客户端的连接时，accept线程就会读取客户端发送的数据，并放入缓冲区。然后那多个工作线程就会从缓冲区取出数据并加以处理。就可以避免针对每一个用户请求都开线程。不仅减少了线程的资源，也提高了线程的利用率。

多个线程的关系应该是这样的。accept线程，只负责客户端的连接处理。假如：客户端C1连上服务端，accept线程，取出数据并放入缓冲区。这时工作线程开始工作，假如为worker3，worker3运行一段时间后，轮到worker1开始运行。worker1就后接手worker3的工作，继续进行。

为了更好使用IOCP，我们要先了解几个常用的函数。

1、CreateIoCompletionPort,首先使用这个函数创建一个Handle 用来标识一个io完成端口。然后会调用它来关联accept的套接字，和一个存在的io完成端口。

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

CreateIoCompletionPort( ( HANDLE)pPerHandle->s, hIocp, (DWORD)pPerHandle, 0 );

2、WSARecv，使用这个函数来接收客户端的数据，并把数据放入缓冲区，让工作线程(事先开好的N个线程)来取。注意dwFlags通常设为0，否则会出错。

WSARecv( pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pPerIo->ol, NULL );

3、GetQueuedCompletionStatus,工作线程使用这个函数来获取放入缓冲区的数据。

GetQueuedCompletionStatus( hIocp, &dwTrans, (LPDWORD)&pPerHandle, (LPOVERLAPPED*)&pPerIo, WSA_INFINITE );

pPerHandle和pPerIo是我们自定义的数据结构，我们使用它来和工作线程进行数据交换。pPerHandle没固定要求，不过我们通常这样定义:

typedef struct _PER_HANDLE_DATA
{
SOCKET s; // 对应的套接字句柄
sockaddr_in addr; // 对方的地址
}PER_HANDLE_DATA, *PPER_HANDLE_DATA;

pPerIo必须包含一个OVERLAPPED的结构，我们通常这样定义：

typedef struct _PER_IO_DATA
{
    OVERLAPPED ol;                 // 重叠结构
    char        buf[BUFFER_SIZE];   // 数据缓冲区
    int         nOperationType;     // 操作类型
#define OP_READ   1
#define OP_WRITE 2
#define OP_ACCEPT 3
}PER_IO_DATA, *PPER_IO_DATA;

IOCP的TCP服务器端的源码如下：(或者见http://download.csdn.net/detail/cloud95/4183205)

注意 RECV_ONLY宏，表示服务器端只接收数据。服务端和客户端此宏的定义应保持一致。

[cpp] view plaincopy
//#define RECV_ONLY  //是否只处理接收数据  
#define BUFFER_SIZE 1024  
/******************************************************************  
* per_handle 数据  
*******************************************************************/   
typedef struct _PER_HANDLE_DATA   
{   
    SOCKET      s;      // 对应的套接字句柄   
    sockaddr_in addr;   // 对方的地址  
}PER_HANDLE_DATA, *PPER_HANDLE_DATA;  
/******************************************************************  
* per_io 数据  
*******************************************************************/   
typedef struct _PER_IO_DATA   
{   
    OVERLAPPED ol;                 // 重叠结构   
    char        buf[BUFFER_SIZE];   // 数据缓冲区   
    int         nOperationType;     // 操作类型  
#define OP_READ   1   
#define OP_WRITE 2   
#define OP_ACCEPT 3  
}PER_IO_DATA, *PPER_IO_DATA;  
  
// 唯一的应用程序对象  
  
CWinApp theApp;  
  
using namespace std;  
DWORD WINAPI ServerThread( LPVOID lpParam );//工作线程  
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])  
{  
    int nRetCode = 0;  
  
    // 初始化 MFC 并在失败时显示错误  
    if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))  
    {  
        // TODO: 更改错误代码以符合您的需要  
        _tprintf(_T("错误: MFC 初始化失败\n"));  
        nRetCode = 1;  
    }  
    else  
    {  
        // TODO: 在此处为应用程序的行为编写代码。  
          
        int nPort =65000;//指定通信端口  
  
        // 创建完成端口对象   
        // 创建工作线程处理完成端口对象的事件   
        HANDLE hIocp = CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0, 0, 0 );   
  
        //cpu个数*2+2 通常为最佳线程数  
        SYSTEM_INFO sysInfo;  
        GetSystemInfo(&sysInfo);  
        int ThreadNum=sysInfo.dwNumberOfProcessors*2+2;  
  
        for(int i=0;i<ThreadNum;i++)  
        {  
            HANDLE hThread;  
            hThread =CreateThread(NULL, 0, ServerThread, (LPVOID)hIocp, 0, 0);  
            CloseHandle(hThread);  
        }  
  
        WSADATA wsaData;  
        WSAStartup( MAKEWORD( 2, 2 ), &wsaData );  
  
        // 创建监听套接字，绑定本地端口，开始监听   
        SOCKET sListen = socket( AF_INET,SOCK_STREAM, 0 );  
        SOCKADDR_IN addr;   
        addr.sin_family = AF_INET;   
        addr.sin_port = htons( nPort );   
        addr.sin_addr.S_un.S_addr = INADDR_ANY;   
        bind( sListen, (sockaddr *)&addr, sizeof( addr ) );   
        listen( sListen, 5 );  
        printf( "iocp demo start......\n" );  
  
        while(true)  
        {  
            //accept客户端  
            SOCKADDR_IN saRemote;   
            int nRemoteLen = sizeof( saRemote );   
            SOCKET sRemote = accept( sListen, (sockaddr *)&saRemote, &nRemoteLen );  
  
            PPER_HANDLE_DATA pPerHandle =(PPER_HANDLE_DATA)::GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA));  
            if( pPerHandle == NULL )   
            {   
                break;   
            }  
            pPerHandle->s = sRemote;   
            memcpy( &pPerHandle->addr, &saRemote, nRemoteLen );  
  
            //关联iocp和接收socket  
            CreateIoCompletionPort( ( HANDLE)pPerHandle->s, hIocp, (DWORD)pPerHandle, 0 );  
  
            PPER_IO_DATA pIoData =(PPER_IO_DATA)GlobalAlloc(GPTR, sizeof(PER_IO_DATA));  
  
            if( pIoData == NULL )   
            {   
                break;   
            }  
            pIoData->nOperationType = OP_READ;   
            WSABUF buf;   
            buf.buf = pIoData->buf;   
            buf.len = BUFFER_SIZE;   
  
            DWORD dwRecv = 0;   
            DWORD dwFlags = 0;//注意保证dwFlags为0，否则会出错  
            //压缩数据到缓冲区  
            WSARecv( pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pIoData->ol, NULL );  
        }  
    }  
  
    return nRetCode;  
}  
  
  
/******************************************************************  
* 函数介绍：处理完成端口对象事件的线程  
* 输入参数：  
* 输出参数：  
* 返回值 ：  
*******************************************************************/   
DWORD WINAPI ServerThread( LPVOID lpParam )   
{   
    HANDLE hIocp = ( HANDLE )lpParam;   
    if( hIocp == NULL )   
    {   
        return -1;   
    }  
    DWORD dwTrans = 0;   
    PPER_HANDLE_DATA pPerHandle;   
    PPER_IO_DATA     pPerIo;   
       
    while( TRUE )   
    {   
        // 在关联到此完成端口的所有套接字上等待I/O完成   
        BOOL bRet = GetQueuedCompletionStatus( hIocp, &dwTrans, (LPDWORD)&pPerHandle, (LPOVERLAPPED*)&pPerIo, WSA_INFINITE );   
        if( !bRet )     // 发生错误   
        {   
            closesocket( pPerHandle->s );   
            GlobalFree( pPerHandle );   
            GlobalFree( pPerIo );  
            cout << "error" << endl;   
            continue;   
        }  
        // 套接字被对方关闭   
        if( dwTrans == 0 && ( pPerIo->nOperationType == OP_READ || pPerIo->nOperationType== OP_WRITE ) )   
        {   
            closesocket( pPerHandle->s );   
            GlobalFree( pPerHandle );   
            GlobalFree( pPerIo );  
            cout << "client closed" << endl;   
            continue;   
        }  
        switch ( pPerIo->nOperationType )   
        {   
        case OP_READ:       // 完成一个接收请求   
            {   
                pPerIo->buf[dwTrans] = '\0';   
                printf( "%s\n", pPerIo->buf );  
  
                #ifdef RECV_ONLY  
                // 继续投递接受操作                   
                WSABUF buf;   
                buf.buf = pPerIo->buf;   
                buf.len = BUFFER_SIZE;   
                pPerIo->nOperationType = OP_READ;                    
                DWORD dwRecv = 0;   
                DWORD dwFlags = 0;  
                //压缩数据到缓冲区  
                WSARecv( pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pPerIo->ol, NULL );  
                #else  
                //回应客户端  
                ZeroMemory(pPerIo->buf,BUFFER_SIZE);  
                strcpy(pPerIo->buf,"OK");  
                DWORD dwSend = 0;   
                DWORD dwFlags = 0;  
                ZeroMemory((LPVOID)&(pPerIo->ol),sizeof(OVERLAPPED));  
                WSABUF buf;   
                buf.buf = pPerIo->buf;   
                buf.len = 2;   
                pPerIo->nOperationType = OP_WRITE;                 
                //发送数据  
                WSASend(pPerHandle->s,&buf,1,&dwSend,dwFlags,&pPerIo->ol,NULL);                 
                #endif                
            }   
            break;   
        case OP_WRITE:   
            {  
                #ifdef RECV_ONLY  
                 
                #else  
                //发送时的处理  
  
                // 继续投递接受操作                   
                WSABUF buf;   
                buf.buf = pPerIo->buf;   
                buf.len = BUFFER_SIZE;   
                pPerIo->nOperationType = OP_READ;                    
                DWORD dwRecv = 0;   
                DWORD dwFlags = 0;  
                //压缩数据到缓冲区  
                WSARecv( pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pPerIo->ol, NULL );  
                #endif            
            }  
            break;  
        case OP_ACCEPT:   
            break;  
        }  
    }  
    return 0;   
}  

原帖地址: http://blog.csdn.net/cloud95/article/details/7406128