Socket I/O 模型 学习

我们为什么要使用Socket I/O模型呢？还得从Socket的阻塞和非阻塞说起。

在网上看过一篇讲解I/O模型的文章，它举过一个例子觉得挺好,那就是收信的例子。

比如:老周在等待他女儿从美国寄过来的信件，老周住三楼，信箱在一楼。有以下几种情况：

第一：老周一直守在信箱旁边，直到收到信件为止。这样太费精力。这就好比是阻塞套接字。

第二：老周到信箱那里看一下，发现还没有来，就马上回家了。这就好比非阻塞套接字。

第三：老周先打个电话到一楼管理员问一下自己的信件是否到了，如果到了才下楼去取信件。当然这样浪费电话费，但是值得的。这可以比作Socket的Select I/O模型。

 
 1 #include "stdafx.h"
 2 #include <iostream>
 3 #include <winsock2.h>
 4 #include <windows.h>
 5 
 6 #define TRACE ATLTrace //必须要加上这个宏定义，否则在WIN32的控制台程序中是不能直接用的
 7 
 8 #define InternetAddr "127.0.0.1"
 9 #define iPort 5055
10 
11 #pragma comment(lib, "ws2_32.lib")
12 
13 int _tmain(int argc, _TCHAR* argv[])
14 {
15     WSADATA wsa;
16     WORD wVersionRequested;
17     int err;
18 
19    wVersionRequested = MAKEWORD( 2, 2 );
20     err = WSAStartup( wVersionRequested, &wsa);
21     if ( err != 0 ) {
22     //Tell the user that we could not find a usable 
23     //WinSock DLL.     
24     TRACE("你忘记添加WinSock DLL了\n");
25     WSACleanup();
26     return 1;
27      }
28 
29    // Create a SOCKET for listening for  incoming connection requests
30     SOCKET fdServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
31    
32     sockaddr_in server;
33 
34 　server.sin_family = AF_INET;
35 　server.sin_addr.s_addr = inet_addr(InternetAddr);
36 　server.sin_port = htons(iPort);
37  //Bind the socket.
38     int ret = bind(fdServer, (sockaddr*)&server, sizeof(server));
39     ret = listen(fdServer, 4);
40 
41     SOCKET AcceptSocket;
42     fd_set     fdread;
43 　timeval    tv;
44 　int nSize;
45    //其实也算是轮训，那么对阻塞socket用select和对使用非阻塞socket的优点在哪？
46   //可能的优点就是避免在非阻塞套接字里重复检查WSAEWOULDBLOCK错误。
47   while(1)
48  　{
49          　　　　　　　　
50          FD_ZERO(&fdread);//初始化fd_set
51          FD_SET(fdServer, &fdread);//分配套接字句柄到相应的fd_set
52                      　　　　　　　　
53         tv.tv_sec = 2;//这里我们打算让select等待两秒后返回，避免被锁死，也避免马上返回
54         tv.tv_usec = 0;
55                                          　　　　　　　　
56         select(0, &fdread, NULL, NULL, &tv);
57                                                  　　　　　　　　
58         nSize = sizeof(server);
59         //先判断fdServer是否还在fd_set内来判断是否可以读，这样就避免因为 accept在等待
60         //时造成的阻塞
61         if (FD_ISSET(fdServer, &fdread))
62             //如果套接字句柄还在fd_set里，说明客户端已经有connect的请求发过来了，
63             //马上可以accept成功
64         　{
65              AcceptSocket = accept(fdServer,( sockaddr*) &server, &nSize);
66              break;
67            }                                     　　　　　　　　
68         else
69         //还没有客户端的connect请求，我们可以去做别的事，避免像没有用select方式
70         //的阻塞套接字程序被锁死的情况，如果没用select,当程序运行到accept的时候客户
71         //端恰好没有connect请求，那么程序就会被锁死，做不了任何事情
72             {
73             //do something
74                MessageBox(NULL, "waiting", "recv", MB_ICONINFORMATION);
75         //别的事做完后，继续去检查是否有客户端连接请求
76             }
77  　　}
78 
79  　　char buffer[128];
80      　ZeroMemory(buffer, 128);
81 
82          ret = recv(AcceptSocket,buffer,128,0);//这里同样可以用select，用法和上面一样
83 
84          MessageBox(NULL, buffer, "recv", MB_ICONINFORMATION);
85 
86         closesocket(AcceptSocket);
87         WSACleanup();
88         return 0;
89 }

第四：老周告诉一楼管理员，如果有他的信件就通知老周。这可以比做Socket的WSAAsynSelect模型 

  
  1 #include <winsock.h>
  2 #include <tchar.h>
  3 
  4 #define PORT         5150
  5 #define MSGSIZE      1024
  6 #define WM_SOCKET WM_USER+0
  7 
  8 #pragma comment(lib, "ws2_32.lib")
  9 
 10 LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 11 
 12 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
 13 {
 14      static TCHAR szAppName[] = _T("AsyncSelect Model");
 15      HWND            hwnd ;
 16      MSG             msg ;
 17      WNDCLASS        wndclass ;
 18 
 19      wndclass.style            = CS_HREDRAW | CS_VREDRAW ;
 20      wndclass.lpfnWndProc      = WndProc ;
 21      wndclass.cbClsExtra       = 0 ;
 22      wndclass.cbWndExtra       = 0 ;
 23      wndclass.hInstance        = hInstance ;
 24      wndclass.hIcon            = LoadIcon (NULL, IDI_APPLICATION) ;
 25      wndclass.hCursor          = LoadCursor (NULL, IDC_ARROW) ;
 26      wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
 27      wndclass.lpszMenuName     = NULL ;
 28      wndclass.lpszClassName = szAppName ;
 29 
 30      if (!RegisterClass(&wndclass))
 31      {
 32        MessageBox (NULL, TEXT ("This program requires Windows NT!"), szAppName, MB_ICONERROR) ;
 33        return 0 ;
 34      }
 35 
 36      hwnd = CreateWindow (szAppName,                     // window class name
 37                           TEXT ("AsyncSelect Model"), // window caption
 38                           WS_OVERLAPPEDWINDOW,           // window style
 39                           CW_USEDEFAULT,                 // initial x position
 40                           CW_USEDEFAULT,                 // initial y position
 41                           CW_USEDEFAULT,                 // initial x size
 42                           CW_USEDEFAULT,                 // initial y size
 43                           NULL,                          // parent window handle
 44                           NULL,                          // window menu handle
 45                           hInstance,                     // program instance handle
 46                           NULL) ;                        // creation parameters
 47 
 48      ShowWindow(hwnd, iCmdShow);
 49      UpdateWindow(hwnd);
 50 
 51      while (GetMessage(&msg, NULL, 0, 0))
 52      {
 53        TranslateMessage(&msg) ;
 54        DispatchMessage(&msg) ;
 55      }
 56   
 57      return msg.wParam;
 58 }
 59 
 60 LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 61 {
 62      WSADATA          wsd;
 63      static SOCKET sListen;
 64      SOCKET           sClient;
 65      SOCKADDR_IN      local, client;
 66      int              ret, iAddrSize = sizeof(client);
 67      char             szMessage[MSGSIZE];
 68 
 69      switch (message)
 70      {
 71 case WM_CREATE:
 72        // Initialize Windows Socket library
 73      WSAStartup(0x0202, &wsd);
 74   
 75      // Create listening socket
 76        sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 77     
 78      // Bind
 79        local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
 80      local.sin_family = AF_INET;
 81      local.sin_port = htons(PORT);
 82      bind(sListen, (struct sockaddr *)&local, sizeof(local));
 83   
 84      // Listen
 85        listen(sListen, 3);
 86 
 87        // Associate listening socket with FD_ACCEPT event
 88      WSAAsyncSelect(sListen, hwnd, WM_SOCKET, FD_ACCEPT);
 89      return 0;
 90 
 91      case WM_DESTROY:
 92        closesocket(sListen);
 93        WSACleanup();
 94        PostQuitMessage(0);
 95        return 0;
 96   
 97      case WM_SOCKET:
 98        if (WSAGETSELECTERROR(lParam))//lParam的高字节包含了可能出现的任何的错误代码
 99        {
100          closesocket(wParam);
101          break;
102        }
103     
104        switch (WSAGETSELECTEVENT(lParam)) //lParam的低字节指定已经发生的网络事件
105        {
106        case FD_ACCEPT:
107          // Accept a connection from client
108          sClient = accept(wParam, (struct sockaddr *)&client, &iAddrSize);
109       
110          // Associate client socket with FD_READ and FD_CLOSE event
111          WSAAsyncSelect(sClient, hwnd, WM_SOCKET, FD_READ | FD_CLOSE);
112          break;
113 
114        case FD_READ:
115          ret = recv(wParam, szMessage, MSGSIZE, 0);
116 
117          if (ret == 0 || ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET)
118          {
119            closesocket(wParam);
120          }
121          else
122          {
123            szMessage[ret] = '\0';
124            send(wParam, szMessage, strlen(szMessage), 0);
125          }
126          break;
127       
128        case FD_CLOSE:
129          closesocket(wParam);      
130          break;
131        }
132        return 0;
133      }
134   
135      return DefWindowProc(hwnd, message, wParam, lParam);
136 }

 第五：老周要一楼管理员发个短信到他们家里去。相当如WSAEventSelect模型，其实WSAEventSelect模型类似WSAAsynSelect模型，但最主要的区别是网络事件发生时会被发送到一个事件对象句柄，而不是发送到一个窗口。这样可能更加的好，对于服务器端的程序来说。

 
 1 SOCKET       Socket[WSA_MAXIMUM_WAIT_EVENTS];
 2 WSAEVENT   Event[WSA_MAXINUM_WAIT_EVENTS];
 3 SOCKET    Accept, Listen;
 5 DWORD     EventTotal = 0;
 6 DWORD     Index;
 7 
 8 //Set up a TCP socket for listening on port 5150
 9 Listen = socket(PF_INET,SOCK_STREAM,0);
10 
11 InternetAddr.sin_family      = AF_INET;
12 InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
13 InternetAddr.sin_port        = htons(5150);
14 
15 bind(Listen,(PSOCKADDR) &InternetAddr,sizeof(InternetAddr));
16 
17 NewEvent = WSACreateEvent();
18 
19 WSAEventSelect(Listen,NewEvnet,FD_ACCEPT|FD_CLOSE);
20 
21 listen(Listen,5);
22 
23 Socket[EventTotal] = Listen;
24 Event[EventTotal] = NewEvent;
25 EventTotal++;
26 
27 while (TRUE)
28 {
29     //Wait for network events on all sockets
30     Index = WSAWaitForMultipleEvents(EventTotal,EventArray,FALSE,WSA_INFINITE,FALSE);
31 
32     WSAEnumNewWorkEvents(SocketArray[Index-WSA_WAIT_EVENT_0],
33         EventArray[Index-WSA_WAIT_EVENT_0],
34         &NetworkEvents);
35     //Check for FD_ACCEPT messages
36     if (NetworkEvents.lNetworkEvents & FD_ACCEPT)
37     {
38         if (NetworkEvents.iErrorCode[FD_ACCEPT_BIT] !=0)
39         {
40             //Error
41             break;
42         }
43         //Accept a new connection and add it to the socket and event lists
44         Accept = accept(SocketArray[Index-WSA_WAIT_EVENT_0],NULL,NULL);
45 
46         //We cannot process more than WSA_MAXIMUM_WAIT_EVENTS sockets ,
47         //so close the accepted socket
48         if (EventTotal > WSA_MAXIMUM_WAIT_EVENTS)
49         {
50             printf("..");
51             closesocket (Accept);
52             break;
53         }
54         NewEvent = WSACreateEvent();
55 
56         WSAEventSelect(Accept,NewEvent,FD_READ|FD_WRITE|FD_CLOSE);
57 
58         Event[EventTotal] = NewEvent;
59         Socket[EventTotal]= Accept;
60         EventTotal++;
61         prinrt("Socket %d connect\n",Accept);
62     }
63     //Process FD_READ notification
64     if (NetworkEvents.lNetwoAD)rkEvents & FD_RE
65     {
66         if (NetworkEvents.iErrorCode[FD_READ_BIT !=0])
67         {
68             //Error
69             break;
70         }
71 
72         //Read data from the socket
73         recv(Socket[Index-WSA_WAIT_EVENT_0],buffer,sizeof(buffer),0);
74     }
75     //process FD_WRITE notitication
76     if (NetworkEvents.lNetworkEvents & FD_WRITE)
77     {
78         if (NetworkEvents.iErrorCode[FD_WRITE_BIT] !=0)
79         {
80             //Error
81             break;
82         }
83         send(Socket[Index-WSA_WAIT_EVENT_0],buffer,sizeof(buffer),0);
84     }
85     if (NetworkEvents.lNetworkEvents & FD_CLOSE)
86     {
87         if(NetworkEvents.iErrorCode[FD_CLOSE_BIT] !=0)
88         {
89             //Error
90             break;
91         }
92         closesocket (Socket[Index-WSA_WAIT_EVENT_0]);
93         //Remove socket and associated event from the Socket and Event arrays and
94         //decrement eventTotal
95         CompressArrays(Event,Socket,& EventTotal);
96     }
97 }

第六：老周可以要求一楼管理员把信件送到他们家去，好比Overlapped I/O 事件通知模型。

第七：老周还可以要求不仅送信件，还可以要求管理员帮他把信封打开，读给老周听（假设老周为文盲，管理员也够累的），这就是Overlapped I/O 完成例程模型 了。