下面我给出支持单个Socket及支持多个Socket的Console程序代码。先来看看支持单个Socket的程序,考虑到代码简洁性，只给一个框架，同时不进行出错处理。
int main()
{
          WSAOVERLAPPED     Overlapped;
                  
          // 启动Winsock及建立监听套接字
           listen(hListenSocket,  5);
       
           hClientSocket   =   accept(hListenSocket,   NULL,   NULL);
           ZeroMemory(&Overlapped,   sizeof(WSAOVERLAPPED));
           
           nResult   =   WSARecv(...);    // 发出请求
        
          for (; ;)
          {
                   bResult   =   WSAGetOverlappedResult(...);
                   // 函数返回后进行相应的处理
                   nResult   =   WSARecv(...);  // 发出另外一个请求
          }
}
        上面的程序只是想说明一下过程，程序没有实现什么功能。这样做的目的是节约字数，用来说明我下面支持多个Socket的Console应用。请继续看。
        先看一个自定义的结构体，单句柄数据结构，通过该结构,主线程与某个特定的子线程中的套接字相互联系。
         typedef   struct    _PER_HANDLE_DATA
         {
                   SOCKET   hSocket;     // 主键:通信套接字
                  char    szClientIP[16];// 自定义字段:客户端地址
                  int nOperateType;   // 自定义字段:操作类型
          }PER_HANDLE_DATA,   FAR*  LPPER_HANDLE_DATA;
         在上面的结构中还可以加入自己需要的字段。在我下面的例子程序中，szClientIP是用来保存连接上来的客户端的IP的，这样在主线程将这个结构体传给子线程后，在子线程中根据客户端IP就知道目前处理的是哪个客户端了。下面是程序的大部分，同样除去一些简单的出错输出。
#define     LISTEN_PORT 5000
#define     DATA_BUFSIZE 8192
#define     POST_RECV 0X01   
#define     POST_SEND 0X02

int   main(  )
{
           LPPER_HANDLE_DATA    lpPerHandleData;
           SOCKET               hListenSocket;
           SOCKET               hClientSocket;
           SOCKADDR_IN          ClientAddr;
           int                  nAddrLen;
           HANDLE               hThread; 

          // Start WinSock and create a listen socket.

          listen(hListenSocket,  5); 
          for (; ;)
         {
                  nAddrLen  =  sizeof(SOCKADDR);
                  hClientSocket  =  accept(hListenSocket,  (LPSOCKADDR)&ClientAddr,  &nAddrLen);

                  lpPerHandleData = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
                  lpPerHandleData->hSocket  =  hClientSocket;
                  // 注意这里将连接的客户端的IP地址，保存到了lpPerHandleData字段中了
                 strcpy(lpPerHandleData->szClientIP,   inet_ntoa(ClientAddr.sin_addr));

                 // 为本次客户请求产生子线程
                 hThread = CreateThread(
                           NULL,
                           0,
                           OverlappedThread,
                           lpPerHandleData,   // 将lpPerHandleData传给子线程
                           0,
                           NULL
                  );
                 CloseHandle(hThread);
         }   
 return 0;
}

DWORD   WINAPI   OverlappedThread(LPVOID    lpParam)
{
            LPPER_HANDLE_DATA     lpPerHandleData   =   (LPPER_HANDLE_DATA)lpParam;
            WSAOVERLAPPED Overlapped;
            WSABUF        wsaBuf;
            char          Buffer[DATA_BUFSIZE];
            BOOL          bResult;
            int           nResult;
   
            ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));
            wsaBuf.buf = Buffer;
            wsaBuf.len = sizeof(Buffer);
            lpPerHandleData->nOperateType = POST_RECV;     // 记录本次操作是Recv(..)

            dwFlags = 0;
            nResult = WSARecv(
                      lpPerHandleData->hSocket,   // Receive socket
                      &wsaBuf,                                  // 指向WSABUF结构的指针
                      1,                                                 // WSABUF数组的个数
                      &dwNumOfBytesRecved,      // 存放当WSARecv完成后所接收到的字节数
                      &dwFlags,                                 // A pointer to flags
                      &Overlapped,                           // A pointer to a WSAOVERLAPPED structure
                      NULL                                         // A pointer to the completion routine,this is NULL
           );
          if   ( nResult   ==   SOCKET_ERROR     &&   GetLastError() !=       WSA_IO_PENDING)
          {
                 printf("WSARecv(..) failed.\n");
                 free(lpPerHandleData);
                 return 1;
          }

         while (TRUE)
         {
                 bResult  =  WSAGetOverlappedResult(
                        lpPerHandleData->hSocket,  
                        &Overlapped,           
                        &dwBytesTransferred,       // 当一个同步I/O完成后,接收到的字节数
                       TRUE,                      // 等待I/O操作的完成
                       &dwFlags                   
                 );
                if   (bResult  ==  FALSE  &&  WSAGetLastError()  !=  WSA_IO_INCOMPLETE)
               {
                         printf("WSAGetOverlappdResult(..) failed.\n");
                         free(lpPerHandleData);
                         return 1;   // 错误退出
                }
        
                if  (dwBytesTransferred == 0)
                {
                           printf("客户端已退出,将断开与之的连接!\n");
                           closesocket(lpPerHandleData->hSocket);
                           free(lpPerHandleData);
                           break;
                }

                 // 在这里将接收到的数据进行处理
               printf("Received from IP: %s.\ndata: %s\n", lpPerHandleData->szClientIP, wsaBuf.buf);    

               // 发送另外一个请求操作
               ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));
               lpPerHandleData->nOperateType = POST_RECV;

               dwFlags = 0;
                nResult = WSARecv(...);
                if (...){}

         }

         return 0;
}
         程序结构比较清晰，lpPerHandleData是主线程与子线程联系的纽带，子线程是通过这个结构获得所处理客户端的情况的。在不同的应用中可以将这个结构定义成不同的形式，以符合所实现应用的需要。注意结构体的nOperateType在GetOverlappedResult返回时用到,可以根据这个字段确定我们下一步的操作。请朋友们多提意见了。