Linux的Socket IO模型趣解_Linux

前言 

之前有看到用很幽默的方式講解Windows的socket IO模型，借用這個故事，講解下linux的socket IO模型； 

老陳有一個在外地工作的女兒，不能經常回來，老陳和她通過信件聯絡。
他們的信會被郵遞員投遞到他們小區門口的收發室裡。這和Socket模型非常類似。 

下面就以老陳接收信件為例講解linux的 Socket I/O模型。 

一、同步阻塞模型 

老陳的女兒第一次去外地工作，送走她之後，老陳非常的掛心她安全到達沒有；
於是老陳什麼也不幹，一直在小區門口收發室裡等著她女兒的報平安的信到； 

這就是linux的同步阻塞模式； 

在這個模式中，使用者空間的應用程式執行一個系統調用，並阻塞，直到系統調用完成為止(資料轉送完成或發生錯誤)。 

Socket設定為阻塞模式，當socket不能立即完成I/O操作時，進程或線程進入等待狀態，直到操作完成。 

如圖1所示：

 

/* * \brief * tcp client */#include #include #include #include #include #define SERVPORT 8080#define MAXDATASIZE 100int main(int argc, char *argv[]){ int sockfd, recvbytes; char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */ char snd_buf[MAXDATASIZE]; struct hostent *host;  /* struct hostent     * {     * char *h_name; // general hostname     * char **h_aliases; // hostname's alias     * int h_addrtype; // AF_INET     * int h_length;      * char **h_addr_list;     * };     */ struct sockaddr_in server_addr; if (argc < 3) { printf("Usage:%s [ip address] [any string]\n", argv[0]); return 1; } *snd_buf = '\0'; strcat(snd_buf, argv[2]); if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket:"); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SERVPORT); inet_pton(AF_INET, argv[1], &server_addr.sin_addr); memset(&(server_addr.sin_zero), 0, 8); /* create the connection by socket  * means that connect "sockfd" to "server_addr" * 同步阻塞模式  */ if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { perror("connect"); exit(1); } /* 同步阻塞模式 */ if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1) { perror("send:"); exit(1); } printf("send:%s\n", snd_buf); /* 同步阻塞模式 */ if ((recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, 0)) == -1) { perror("recv:"); exit(1); } rcv_buf[recvbytes] = '\0'; printf("recv:%s\n", rcv_buf); close(sockfd); return 0;} 

顯然，代碼中的connect, send, recv都是同步阻塞工作模式， 

在結果沒有返回時，程式什麼也不做。
這種模型非常經典，也被廣泛使用。 

優勢在於非常簡單，等待的過程中佔用的系統資源微乎其微，程式調用返回時，必定可以拿到資料；但簡單也帶來一些缺點，程式在資料到來並準備好以前，不能進行其他動作，需要有一個線程專門用於等待，這種代價對於需要處理大量已連線的服務器而言，是很難接受的。 

二、同步非阻塞模型 

收到平安信後，老陳稍稍放心了，就不再一直在收發室前等信，而是每隔一段時間就去收發室檢查信箱，這樣，老陳也能在間隔時間內休息一會，或喝杯荼，看會電視，做點別的事情，這就是同步非阻塞模型。 

同步阻塞 I/O 的一種效率稍低的變種是同步非阻塞 I/O，在這種模型中，系統調用是以非阻塞的形式開啟的，這意味著 I/O 操作不會立即完成， 操作可能會返回一個錯誤碼，說明這個命令不能立即滿足（EAGAIN 或 EWOULDBLOCK），非阻塞的實現是 I/O 命令可能並不會立即滿足，需要應用程式調用許多次來等待操作完成。 

這可能效率不高，因為在很多情況下，當核心執行這個命令時，應用程式必須要進行忙碌等待，直到資料可用為止，或者試圖執行其他工作。因為資料在核心中變為可用到使用者調用 read 返回資料之間存在一定的間隔，這會導致整體資料輸送量的降低。 

如圖2所示：

 

/* * \brief * tcp client */#include #include #include #include #include #include #include #include #include #define SERVPORT 8080#define MAXDATASIZE 100int main(int argc, char *argv[]){ int sockfd, recvbytes; char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */ char snd_buf[MAXDATASIZE]; struct hostent *host;  /* struct hostent     * {     * char *h_name; // general hostname     * char **h_aliases; // hostname's alias     * int h_addrtype; // AF_INET     * int h_length;      * char **h_addr_list;     * };     */ struct sockaddr_in server_addr; int flags; int addr_len; if (argc < 3) { printf("Usage:%s [ip address] [any string]\n", argv[0]); return 1; } *snd_buf = '\0'; strcat(snd_buf, argv[2]); if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket:"); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SERVPORT); inet_pton(AF_INET, argv[1], &server_addr.sin_addr); memset(&(server_addr.sin_zero), 0, 8); addr_len = sizeof(struct sockaddr_in); /* Setting socket to nonblock */ flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, flags|O_NONBLOCK); /* create the connection by socket  * means that connect "sockfd" to "server_addr" * 同步阻塞模式  */ if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { perror("connect"); exit(1); } /* 同步非阻塞模式 */ while (send(sockfd, snd_buf, sizeof(snd_buf), MSG_DONTWAIT) == -1) { sleep(10); printf("sleep\n"); } printf("send:%s\n", snd_buf); /* 同步非阻塞模式 */ while ((recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT)) == -1) { sleep(10); printf("sleep\n"); } rcv_buf[recvbytes] = '\0'; printf("recv:%s\n", rcv_buf); close(sockfd); return 0;} 

這種模式在沒有資料可以接收時，可以進行其他的一些操作，比如有多個socket時，可以去查看其他socket有沒有可以接收的資料；實際應用中，這種I/O模型的直接使用並不常見，因為它需要不停的查詢，而這些查詢大部分會是無必要的調用，白白浪費了系統資源；非阻塞I/O應該算是一個鋪墊，為I/O複用和訊號驅動奠定了非阻塞使用的基礎。 

我們可以使用 fcntl(fd, F_SETFL, flag | O_NONBLOCK);將通訊端標誌變成非阻塞，調用recv，如果裝置暫時沒有資料可讀就返回-1，同時置errno為EWOULDBLOCK（或者EAGAIN，這兩個宏定義的值相同），表示本來應該阻塞在這裡（would block，虛擬語氣），事實上並沒有阻塞而是直接返回錯誤，調用者應該試著再讀一次（again）。 

這種行為方式稱為輪詢（Poll），調用者只是查詢一下，而不是阻塞在這裡死等，這樣可以同時監視多個裝置： 

while(1)
 {
 非阻塞read(裝置1);
 if(裝置1有資料到達)
 處理資料;
 
非阻塞read(裝置2);
 if(裝置2有資料到達)
 處理資料;
 
…………………………
 } 

如果read(裝置1)是阻塞的，那麼只要裝置1沒有資料到達就會一直阻塞在裝置1的read調用上，即使裝置2有資料到達也不能處理，使用非阻塞I/O就可以避免裝置2得不到及時處理。非阻塞I/O有一個缺點，如果所有裝置都一直沒有資料到達，調用者需要反覆查詢做無用功，如果阻塞在那裡，作業系統可以調度別的進程執行，就不會做無用功了，在實際應用中非阻塞I/O模型比較少用 

三、I/O 複用(非同步阻塞)模式 

頻繁地去收發室對老陳來說太累了，在間隔的時間內能做的事也很少，而且取到信的效率也很低. 

於是，老陳向小區物業提了建議； 

小區物業改進了他們的信箱系統： 

住戶先向小區物業註冊，之後小區物業會在登入的住戶的家中添加一個提醒裝置，每當有註冊房屋的新的信件來臨，此裝置會發出 “新信件到達”聲，提醒老陳去看是不是自己的信到了。這就是非同步阻塞模型。 

在這種模型中，配置的是非阻塞 I/O，然後使用阻塞 select 系統調用來確定一個 I/O 描述符何時有操作。使 select 調用非常有趣的是它可以用來為多個描述符提供通知，而不僅僅為一個描述符提供通知。對於每個提示符來說，我們可以請求這個描述符可以寫資料、有讀資料可用以及是否發生錯誤的通知 

I/O複用模型能讓一個或多個socket可讀或可寫準備好時，應用能被通知到； 

I/O複用模型早期用select實現，它的工作流程如下圖：

 

用select來管理多個I/O，當沒有資料時select阻塞，如果在逾時時間內資料到來則select返回，再調用recv進行資料的複製，recv返回後處理資料。 

下面的C語言實現的例子，它從網路上接受資料寫入一個檔案中:

 /* * \brief * tcp client */#include #include #include #include #include #include #include #include #include #include #define SERVPORT 8080#define MAXDATASIZE 100#define TFILE "data_from_socket.txt"int main(int argc, char *argv[]){ int sockfd, recvbytes; char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */ char snd_buf[MAXDATASIZE]; struct hostent *host;  /* struct hostent     * {     * char *h_name; // general hostname     * char **h_aliases; // hostname's alias     * int h_addrtype; // AF_INET     * int h_length;      * char **h_addr_list;     * };     */ struct sockaddr_in server_addr; /* */ fd_set readset, writeset; int check_timeval = 1; struct timeval timeout={check_timeval,0}; //阻塞式select, 等待1秒，1秒輪詢 int maxfd; int fp; int cir_count = 0; int ret; if (argc < 3) { printf("Usage:%s [ip address] [any string]\n", argv[0]); return 1; } *snd_buf = '\0'; strcat(snd_buf, argv[2]); if ((fp = open(TFILE,O_WRONLY)) < 0) //不是用fopen { perror("fopen:"); exit(1); } if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket:"); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SERVPORT); inet_pton(AF_INET, argv[1], &server_addr.sin_addr); memset(&(server_addr.sin_zero), 0, 8); /* create the connection by socket  * means that connect "sockfd" to "server_addr" */ if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { perror("connect"); exit(1); } /**/ if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1) { perror("send:"); exit(1); } printf("send:%s\n", snd_buf); while (1) { FD_ZERO(&readset);  //每次迴圈都要清空集合，否則不能檢測描述符變化 FD_SET(sockfd, &readset); //添加描述符  FD_ZERO(&writeset); FD_SET(fp, &writeset); maxfd = sockfd > fp ? (sockfd+1) : (fp+1); //描述符最大值加1 ret = select(maxfd, &readset, NULL, NULL, NULL); // 阻塞模式 switch( ret) { case -1: exit(-1); break; case 0: break; default: if (FD_ISSET(sockfd, &readset)) //測試sock是否可讀，即是否網路上有資料 {  recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT);  rcv_buf[recvbytes] = '\0';  printf("recv:%s\n", rcv_buf);  if (FD_ISSET(fp, &writeset))  {  write(fp, rcv_buf, strlen(rcv_buf)); // 不是用fwrite  }  goto end; } } cir_count++; printf("CNT : %d \n",cir_count); }end: close(fp); close(sockfd); return 0;} 

perl實現:

 #! /usr/bin/perl################################################################################ \File# tcp_client.pl# \Descript# send message to server###############################################################################use IO::Socket;use IO::Select;#hash to install IP Port%srv_info =(#"srv_ip" => "61.184.93.197", "srv_ip" => "192.168.1.73", "srv_port"=> "8080", );my $srv_addr = $srv_info{"srv_ip"};my $srv_port = $srv_info{"srv_port"};my $sock = IO::Socket::INET->new( PeerAddr => "$srv_addr", PeerPort => "$srv_port", Type => SOCK_STREAM, Blocking => 1,# Timeout => 5, Proto => "tcp")or die "Can not create socket connect. $@";$sock->send("Hello server!\n", 0) or warn "send failed: $!, $@";$sock->autoflush(1);my $sel = IO::Select->new($sock);while(my @ready = $sel->can_read){ foreach my $fh(@ready) { if($fh == $sock) { while() { print $_; } $sel->remove($fh); close $fh; } }}$sock->close(); 

四、訊號驅動 I/O 模型

老陳接收到新的信件後，一般的程式是： 

開啟信封—-掏出信紙 —-閱讀信件—-回複信件 ……為了進一步減輕使用者負擔，小區物業又開發了一種新的技術：住戶只要告訴小區物業對信件的操作步驟，小區物業信箱將按照這些步驟去處理信件，不再需要使用者親自拆信 /閱讀/回複了！這就是訊號驅動I/O模型。 

我們也可以用訊號，讓核心在描述字就緒時發送SIGIO訊號通知我們。 

首先開啟套介面的訊號驅動 I/O功能，並通過sigaction系統調用安裝一個訊號處理函數。該系統調用將立即返回，我們的進程繼續工作，也就是說沒被阻塞。當資料報準備好讀取時，核心就為該進程產生一個SIGIO訊號，我們隨後既可以在訊號處理函數中調用recvfrom讀取資料報，並通知主迴圈資料已準備好待處理，也可以立即通知主迴圈，讓它讀取資料報。 

無論如何處理SIGIO訊號，這種模型的優勢在於等待資料報到達期間，進程不被阻塞，主迴圈可以繼續執行，只要不時地等待來自訊號處理函數的通知：既可以是資料已準備好被處理，也可以是資料報已準備好被讀取。 

五、非同步非阻塞模式 

linux下的asynchronous IO其實用得很少。 

與前面的訊號驅動模型的主要區別在於：訊號驅動 I/O是由核心通知我們何時可以啟動一個 I/O操作，而非同步 I/O模型是由核心通知我們 I/O操作何時完成 。 

先看一下它的流程：

 

這就是非同步非阻塞模式 

以read系統調用為例 

steps： 

a. 調用read;
b. read請求會立即返回，說明請求已經成功發起了。
c. 在後台完成讀操作這段時間內，應用程式可以執行其他處理操作。
d. 當 read 的響應到達時，就會產生一個訊號或執行一個基於線程的回呼函數來完成這次 I/O 處理過程。

 /* * \brief * tcp client */#include #include #include #include #include #include #include#include #include #include #define SERVPORT 8080#define MAXDATASIZE 100#define TFILE "data_from_socket.txt"int main(int argc, char *argv[]){ int sockfd, recvbytes; char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */ char snd_buf[MAXDATASIZE]; struct hostent *host;    /* struct hostent          * {          * char *h_name; // general hostname          * char **h_aliases; // hostname's alias          * int h_addrtype; // AF_INET          * int h_length;           * char **h_addr_list;          * };          */ struct sockaddr_in server_addr; /* */ fd_set readset, writeset; int check_timeval = 1; struct timeval timeout={check_timeval,0}; //阻塞式select, 等待1秒，1秒輪詢 int maxfd; int fp; int cir_count = 0; int ret; if (argc < 3) { printf("Usage:%s [ip address] [any string]\n", argv[0]); return 1; } *snd_buf = '\0'; strcat(snd_buf, argv[2]); if ((fp = open(TFILE,O_WRONLY)) < 0) //不是用fopen { perror("fopen:"); exit(1); } if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket:"); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SERVPORT); inet_pton(AF_INET, argv[1], &server_addr.sin_addr); memset(&(server_addr.sin_zero), 0, 8); /* create the connection by socket  * means that connect "sockfd" to "server_addr" */ if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { perror("connect"); exit(1); } /**/ if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1) { perror("send:"); exit(1); } printf("send:%s\n", snd_buf); while (1) { FD_ZERO(&readset);   //每次迴圈都要清空集合，否則不能檢測描述符變化 FD_SET(sockfd, &readset);  //添加描述符   FD_ZERO(&writeset); FD_SET(fp,  &writeset); maxfd = sockfd > fp ? (sockfd+1) : (fp+1); //描述符最大值加1 ret = select(maxfd, &readset, NULL, NULL, &timeout); // 非阻塞模式 switch( ret) {  case -1:  exit(-1);  break;  case 0:  break;  default:  if (FD_ISSET(sockfd, &readset)) //測試sock是否可讀，即是否網路上有資料  {   recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT);   rcv_buf[recvbytes] = '\0';   printf("recv:%s\n", rcv_buf);   if (FD_ISSET(fp, &writeset))   {   write(fp, rcv_buf, strlen(rcv_buf)); // 不是用fwrite   }   goto end;  } } timeout.tv_sec = check_timeval; // 必須重新設定，因為逾時時間到後會將其置零 cir_count++; printf("CNT : %d \n",cir_count); }end: close(fp); close(sockfd); return 0;} 

server端程式:

 /* * \brief * tcp server */#include #include #include #include #include #include #include #define SERVPORT 8080#define BACKLOG 10 // max numbef of client connection#define MAXDATASIZE 100int main(char argc, char *argv[]){ int sockfd, client_fd, addr_size, recvbytes; char rcv_buf[MAXDATASIZE], snd_buf[MAXDATASIZE]; char* val; struct sockaddr_in server_addr; struct sockaddr_in client_addr; int bReuseaddr = 1; char IPdotdec[20]; /* create a new socket and regiter it to os . * SOCK_STREAM means that supply tcp service,  * and must connect() before data transfort. */ if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket:"); exit(1); } /* setting server's socket */ server_addr.sin_family = AF_INET;   // IPv4 network protocol server_addr.sin_port = htons(SERVPORT); server_addr.sin_addr.s_addr = INADDR_ANY; // auto IP detect memset(&(server_addr.sin_zero),0, 8); setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&bReuseaddr, sizeof(int)); if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr))== -1) { perror("bind:"); exit(1); } /*  * watting for connection ,  * and server permit to recive the requestion from sockfd  */ if (listen(sockfd, BACKLOG) == -1) // BACKLOG assign thd max number of connection { perror("listen:"); exit(1);                  }                    while(1)                  {                    addr_size = sizeof(struct sockaddr_in);          /*                    * accept the sockfd's connection,            * return an new socket and assign far host to client_addr      */                   printf("watting for connect...\n");           if ((client_fd = accept(sockfd, (struct sockaddr *)&client_addr, &addr_size)) == -1)  {                    /* Nonblocking mode */               perror("accept:");                continue;                 }                   /* network-digital to ip address */           inet_ntop(AF_INET, (void*)&client_addr, IPdotdec, 16);      printf("connetion from:%d : %s\n",client_addr.sin_addr, IPdotdec);   //if (!fork())                {                    /* child process handle with the client connection */       /* recive the client's data by client_fd */         if ((recvbytes = recv(client_fd, rcv_buf, MAXDATASIZE, 0)) == -1)    {                    perror("recv:");                exit(1);                  }                    rcv_buf[recvbytes]='\0';              printf("recv:%s\n", rcv_buf);             *snd_buf='\0';                 strcat(snd_buf, "welcome");             sleep(3);                  /* send the message to far-hosts by client_fd */        if (send(client_fd, snd_buf, strlen(snd_buf), 0) == -1)      {                    perror("send:");                exit(1);                  }                    printf("send:%s\n", snd_buf);             close(client_fd);                //exit(1);                 }                   //close(client_fd);               } return 0;                 } 

使用者進程發起read操作之後，立刻就可以開始去做其它的事。而另一方面，從kernel的角度，當它受到一個asynchronous read之後，首先它會立刻返回，所以不會對使用者進程產生任何block。然後，kernel會等待資料準備完成，然後將資料拷貝到使用者記憶體，當這一切都完成之後，kernel會給使用者進程發送一個signal，告訴它read操作完成了。 

六、總結 

到目前為止，已經將四個IO Model都介紹完了。

現在回過頭來回答兩個問題：
 blocking和non-blocking的區別在哪?
 synchronous IO和asynchronous IO的區別在哪。 

先回答最簡單的這個：blocking vs non-blocking。 

前面的介紹中其實已經很明確的說明了這兩者的區別。

 調用blocking IO會一直block住對應的進程直到操作完成，
 而non-blocking IO在kernel還在準備資料的情況下會立刻返回。 

在說明synchronous IO和asynchronous IO的區別之前，需要先給出兩者的定義。 

Stevens給出的定義（其實是POSIX的定義）是這樣子的：

複製代碼 代碼如下:

 A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes;

複製代碼 代碼如下:

 An asynchronous I/O operation does not cause the requesting process to be blocked; 

兩者的區別就在於：

synchronous IO做”IO operation”的時候會將process阻塞。 

按照這個定義，之前所述的blocking IO，non-blocking IO，IO multiplexing都屬於synchronous IO。

有人可能會說，non-blocking IO並沒有被block啊。這裡有個非常“狡猾”的地方，定義中所指的”IO operation”是指真實的IO操作，就是例子中的recvfrom這個system call。

non-blocking IO在執行recvfrom這個system call的時候，如果kernel的資料沒有準備好，這時候不會block進程。

但是，當kernel中資料準備好的時候，recvfrom會將資料從kernel拷貝到使用者記憶體中， 這個時候進程是被block了，在這段時間內，進程是被block的。

而asynchronous IO則不一樣，當進程發起IO 操作之後，就直接返回再也不理睬了，直到kernel發送一個訊號，告訴進程說IO完成。在這整個過程中，進程完全沒有被block。 

各個IO Model的比較如圖所示：

 

經過上面的介紹，會發現non-blocking IO和asynchronous IO的區別還是很明顯的: 

在non-blocking IO中，雖然進程大部分時間都不會被block，但是它仍然要求進程去主動的check，並且當資料準備完成以後，也需要進程主動的再次調用recvfrom來將資料拷貝到使用者記憶體。 

而asynchronous IO則完全不同。它就像是使用者進程將整個IO操作交給了他人（kernel）完成，然後他人做完後發訊號通知。在此期間，使用者進程不需要去檢查IO操作的狀態，也不需要主動的去拷貝資料。 

最後，再舉幾個不是很恰當的例子來說明這五個IO Model: 

有A，B，C，D，E五個人釣魚： 

A用的是最老式的魚竿，所以呢，得一直守著，等到魚上鉤了再拉杆； 
B的魚竿有個功能，能夠顯示是否有魚上鉤，所以呢，B就和旁邊的MM聊天，隔會再看看有沒有魚上鉤，有的話就迅速拉杆； 
C用的魚竿和B差不多，但他想了一個好辦法，就是同時放好幾根魚竿，然後守在旁邊，一旦有顯示說魚上鉤了，它就將對應的魚竿拉起來； 
D是個有錢人，他沒耐心等， 但是又喜歡釣上魚的快感，所以雇了個人，一旦那個人發現有魚上鉤，就會通知D過來把魚釣上來； 
E也是個有錢人，乾脆雇了一個人幫他釣魚，一旦那個人把魚釣上來了，就給E發個簡訊。

以上就是本文的全部內容，希望對大家的學習有所協助，也希望大家多多支援雲棲社區。