windows下iocp的简单代码

//////server
#include <WinSock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>

//该例子代码在并发情况下存在问题，需要对clientRecord进行mutex保护才能保证操作的有效性。

#define HOST_PORT                   10000
#define MAX_BUFF_SIZE               8192


typedef struct msg_watch_para_struct msg_watch_para_t;
struct msg_watch_para_struct {
    HANDLE      cp;
};

typedef struct wsa_data_struct wsa_data_t;
struct wsa_data_struct {
    WSAOVERLAPPED               Overlapped;

    char                        Buffer[MAX_BUFF_SIZE];
    WSABUF                      wsabuf;
    int                         nTotalBytes;
    int                         nSentBytes;
    SOCKET                      SocketAccept; 
};

typedef struct port_info_struct port_info_t;
struct port_info_struct {
    int         client_socket;
    wsa_data_t  *pIOContext;
};

void CALLBACK CompletionROUTINE(
  IN DWORD dwError, 
  IN DWORD cbTransferred, 
  IN LPWSAOVERLAPPED lpOverlapped, 
  IN DWORD dwFlags
)
{
    //仅仅是为了看lpOverlapped的值
    wsa_data_t      *was_data = (wsa_data_t*)lpOverlapped;
}


//接收线程
unsigned
__stdcall
msg_watch_thread(void*   p)
{
    msg_watch_para_t    *para = (msg_watch_para_t*)p;
    port_info_t         *port_info;
    char                buf[1024 * 11];
    LPWSAOVERLAPPED     lpOverlapped = NULL;
    wsa_data_t          *was_data;

    BOOL bSuccess = FALSE;
    DWORD dwIoSize = 0;

    while (1)
    {
        bSuccess = GetQueuedCompletionStatus(para->cp, &dwIoSize,
                                                (PDWORD_PTR)&port_info,
                                                &lpOverlapped, 
                                                INFINITE);
        if (!bSuccess)
        {
            DWORD ecode = GetLastError();
        }

        was_data = (wsa_data_t*)lpOverlapped;

        {
            DWORD dwRecvNumBytes = 0;     
            int nRet = 0;
            DWORD dwFlags = 0;
            while (TRUE)
            {
                nRet = WSARecv(port_info->client_socket, &(port_info->pIOContext->wsabuf), 
                                1, &dwRecvNumBytes, &dwFlags,
                                &(port_info->pIOContext->Overlapped), NULL);
                if( nRet == SOCKET_ERROR  ) 
                {
                    if ((ERROR_IO_PENDING != WSAGetLastError()))    //数据读取完成
                        break;

                    //出现其他错误，关闭端口，干掉session
                    printf("WSARecv() Failed: %d\n", WSAGetLastError());
                }
            }
            buf[1023] = 0;
            send(port_info->client_socket, buf, 1024, 0);
        }
    }

    return 0;
}

int main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
    msg_watch_para_t    watch_para;


    wVersionRequested = MAKEWORD( 2, 2 );

    err = WSAStartup( wVersionRequested, &wsaData );

    if ( err != 0 )
    {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        return 0;
    }

    /* Confirm that the WinSock DLL supports 2.2.*/
    /* Note that if the DLL supports versions greater    */
    /* than 2.2 in addition to 2.2, it will still return */
    /* 2.2 in wVersion since that is the version we      */
    /* requested.                                        */
    if ( LOBYTE( wsaData.wVersion ) != 2 ||
            HIBYTE( wsaData.wVersion ) != 2 )
    {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        WSACleanup( );
        return 0;
    }

    int servfd, clientfd;

    //servfd = socket(AF_INET, SOCK_STREAM, 0);
    servfd = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);

    if(servfd < 0)
    {
        printf("server create socket failed.\n");

        return 0;
    }

    int on = 1;

    if(setsockopt(servfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)) < 0)
    {
        printf("set socket option failed.\n");

        return 0;
    }

    struct sockaddr_in servaddr;

    struct sockaddr_in clientaddr;

    memset(&servaddr,0,sizeof(servaddr));

    memset(&clientaddr,0,sizeof(clientaddr));

    servaddr.sin_family = AF_INET;

    servaddr.sin_port = htons(HOST_PORT);

    servaddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

    if(bind(servfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        printf("bind failed.\n");
        return 0;
    }

    if(listen(servfd,10) < 0)
    {
        printf("listen failed.\n");
        return 0;
    }

    int length = sizeof(clientaddr);

    watch_para.cp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 10);

    //创建消息事件处理线程
    _beginthreadex((void*)NULL,
                       1024 * 512,
                       msg_watch_thread, 
                       &watch_para,
                       0,
                       NULL);


    for(;;)
    {
        HANDLE      cp;
        port_info_t *port_info;
        //接收用户连接
        //clientfd = accept(servfd, (struct sockaddr *)&clientaddr,&length);
        clientfd = WSAAccept(servfd, NULL, NULL, NULL, 0);
        if ( clientfd == SOCKET_ERROR ) 
        {
            printf("socket error.\n");
        }

        //初始化端口
        port_info = (port_info_t*)malloc(sizeof(port_info_t));
        port_info->pIOContext = (wsa_data_t*)malloc(sizeof(wsa_data_t));
        {
            port_info->client_socket = clientfd;
            port_info->pIOContext->Overlapped.Internal = 0;
            port_info->pIOContext->Overlapped.InternalHigh = 0;
            port_info->pIOContext->Overlapped.Offset = 0;
            port_info->pIOContext->Overlapped.OffsetHigh = 0;
            port_info->pIOContext->Overlapped.hEvent = NULL;
            port_info->pIOContext->nTotalBytes = 0;
            port_info->pIOContext->nSentBytes  = 0;
            port_info->pIOContext->wsabuf.buf  = port_info->pIOContext->Buffer;
            port_info->pIOContext->wsabuf.len  = sizeof(port_info->pIOContext->Buffer);
        }

        //将端口加入iocp的数组
        cp = CreateIoCompletionPort((HANDLE)clientfd, watch_para.cp, (ULONG_PTR)port_info, 0);
        if (cp == INVALID_HANDLE_VALUE)
        {
            DWORD ecode = GetLastError();
        }

        {
            DWORD dwRecvNumBytes = 0;     
            int nRet = 0;
            DWORD dwFlags = 0;
            nRet = WSARecv(clientfd, &(port_info->pIOContext->wsabuf), 
                            1, &dwRecvNumBytes, &dwFlags,
                            &(port_info->pIOContext->Overlapped), NULL);
            if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) ) 
            {
                printf("WSARecv() Failed: %d\n", WSAGetLastError());
            }
        }
    }

    closesocket(servfd);

    return 0;
}

只是简单的服务器端iocp的代码实现。msg_watch_thread函数完成消息的接收，这个结构设计的目的是使用专门的线程获得消息事件，但本身并不处理消息事件的内容，再次生成任务抛出，由其他的线程进行消息的处理。通过该种方式简化线程工作内容，使不同的线程专注于某个特定领域的工作，每个iocp的对象只需要一个线程进行对应，如果端口较多，并发量一个线程无法承担，则可以增加新的消息监视线程。

不过这种模型下，任务的生成可能成为处理的瓶颈。任务加入队列和从队列中取出将被多个线程争用。不过可以通过将任务的分成多个不同类型的队列，使用多组队列达到并发的效果。