Linux的Socket IO模型趣解

更新時間：2016年11月16日 16:01:29 投稿：lijiao

這篇文章主要通過一個幽默的方式為大家詳細介紹了Linux的Socket IO模型,具有一定的參考價值，感興趣的小伙伴們可以參考一下

前言

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

老陳有一個在外地工作的女兒，不能經(jīng)常回來，老陳和她通過信件聯(lián)系。
他們的信會被郵遞員投遞到他們小區(qū)門口的收發(fā)室里。這和Socket模型非常類似。

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

一、同步阻塞模型

老陳的女兒第一次去外地工作，送走她之后，老陳非常的掛心她安全到達沒有；
于是老陳什么也不干，一直在小區(qū)門口收發(fā)室里等著她女兒的報平安的信到；

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

在這個模式中，用戶空間的應(yīng)用程序執(zhí)行一個系統(tǒng)調(diào)用，并阻塞，直到系統(tǒng)調(diào)用完成為止(數(shù)據(jù)傳輸完成或發(fā)生錯誤)。

Socket設(shè)置為阻塞模式，當socket不能立即完成I/O操作時，進程或線程進入等待狀態(tài)，直到操作完成。

如圖1所示：

/*
 * \brief
 * tcp client
 */

#include 
#include 
#include 
#include 
#include 
#define SERVPORT 8080
#define MAXDATASIZE 100

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;

 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都是同步阻塞工作模式，

在結(jié)果沒有返回時，程序什么也不做。
這種模型非常經(jīng)典，也被廣泛使用。

優(yōu)勢在于非常簡單，等待的過程中占用的系統(tǒng)資源微乎其微，程序調(diào)用返回時，必定可以拿到數(shù)據(jù)；但簡單也帶來一些缺點，程序在數(shù)據(jù)到來并準備好以前，不能進行其他操作，需要有一個線程專門用于等待，這種代價對于需要處理大量連接的服務(wù)器而言，是很難接受的。

二、同步非阻塞模型

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

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

這可能效率不高，因為在很多情況下，當內(nèi)核執(zhí)行這個命令時，應(yīng)用程序必須要進行忙碌等待，直到數(shù)據(jù)可用為止，或者試圖執(zhí)行其他工作。因為數(shù)據(jù)在內(nèi)核中變?yōu)榭捎玫接脩粽{(diào)用 read 返回數(shù)據(jù)之間存在一定的間隔，這會導致整體數(shù)據(jù)吞吐量的降低。

如圖2所示：

/*
 * \brief
 * tcp client
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SERVPORT 8080
#define MAXDATASIZE 100

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;
 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;
}

這種模式在沒有數(shù)據(jù)可以接收時，可以進行其他的一些操作，比如有多個socket時，可以去查看其他socket有沒有可以接收的數(shù)據(jù)；實際應(yīng)用中，這種I/O模型的直接使用并不常見，因為它需要不停的查詢，而這些查詢大部分會是無必要的調(diào)用，白白浪費了系統(tǒng)資源；非阻塞I/O應(yīng)該算是一個鋪墊，為I/O復(fù)用和信號驅(qū)動奠定了非阻塞使用的基礎(chǔ)。

我們可以使用 fcntl(fd, F_SETFL, flag | O_NONBLOCK);將套接字標志變成非阻塞，調(diào)用recv，如果設(shè)備暫時沒有數(shù)據(jù)可讀就返回-1，同時置errno為EWOULDBLOCK（或者EAGAIN，這兩個宏定義的值相同），表示本來應(yīng)該阻塞在這里（would block，虛擬語氣），事實上并沒有阻塞而是直接返回錯誤，調(diào)用者應(yīng)該試著再讀一次（again）。

這種行為方式稱為輪詢（Poll），調(diào)用者只是查詢一下，而不是阻塞在這里死等，這樣可以同時監(jiān)視多個設(shè)備：

while(1)
{
非阻塞read(設(shè)備1);
if(設(shè)備1有數(shù)據(jù)到達)
處理數(shù)據(jù);

非阻塞read(設(shè)備2);
if(設(shè)備2有數(shù)據(jù)到達)
處理數(shù)據(jù);

…………………………
}

如果read(設(shè)備1)是阻塞的，那么只要設(shè)備1沒有數(shù)據(jù)到達就會一直阻塞在設(shè)備1的read調(diào)用上，即使設(shè)備2有數(shù)據(jù)到達也不能處理，使用非阻塞I/O就可以避免設(shè)備2得不到及時處理。非阻塞I/O有一個缺點，如果所有設(shè)備都一直沒有數(shù)據(jù)到達，調(diào)用者需要反復(fù)查詢做無用功，如果阻塞在那里，操作系統(tǒng)可以調(diào)度別的進程執(zhí)行，就不會做無用功了，在實際應(yīng)用中非阻塞I/O模型比較少用

三、I/O 復(fù)用(異步阻塞)模式

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

于是，老陳向小區(qū)物業(yè)提了建議；

小區(qū)物業(yè)改進了他們的信箱系統(tǒng)：

住戶先向小區(qū)物業(yè)注冊，之后小區(qū)物業(yè)會在已注冊的住戶的家中添加一個提醒裝置，每當有注冊住房的新的信件來臨，此裝置會發(fā)出 “新信件到達”聲，提醒老陳去看是不是自己的信到了。這就是異步阻塞模型。

在這種模型中，配置的是非阻塞 I/O，然后使用阻塞 select 系統(tǒng)調(diào)用來確定一個 I/O 描述符何時有操作。使 select 調(diào)用非常有趣的是它可以用來為多個描述符提供通知，而不僅僅為一個描述符提供通知。對于每個提示符來說，我們可以請求這個描述符可以寫數(shù)據(jù)、有讀數(shù)據(jù)可用以及是否發(fā)生錯誤的通知

I/O復(fù)用模型能讓一個或多個socket可讀或可寫準備好時，應(yīng)用能被通知到；

I/O復(fù)用模型早期用select實現(xiàn)，它的工作流程如下圖：

用select來管理多個I/O，當沒有數(shù)據(jù)時select阻塞，如果在超時時間內(nèi)數(shù)據(jù)到來則select返回，再調(diào)用recv進行數(shù)據(jù)的復(fù)制，recv返回后處理數(shù)據(jù)。

下面的C語言實現(xiàn)的例子，它從網(wǎng)絡(luò)上接受數(shù)據(jù)寫入一個文件中:

 /*
 * \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);  //每次循環(huán)都要清空集合，否則不能檢測描述符變化
 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是否可讀，即是否網(wǎng)絡(luò)上有數(shù)據(jù)
 {
  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實現(xiàn):

 #! /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();

四、信號驅(qū)動 I/O 模型

老陳接收到新的信件后，一般的程序是：

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

我們也可以用信號，讓內(nèi)核在描述字就緒時發(fā)送SIGIO信號通知我們。

首先開啟套接口的信號驅(qū)動 I/O功能，并通過sigaction系統(tǒng)調(diào)用安裝一個信號處理函數(shù)。該系統(tǒng)調(diào)用將立即返回，我們的進程繼續(xù)工作，也就是說沒被阻塞。當數(shù)據(jù)報準備好讀取時，內(nèi)核就為該進程產(chǎn)生一個SIGIO信號，我們隨后既可以在信號處理函數(shù)中調(diào)用recvfrom讀取數(shù)據(jù)報，并通知主循環(huán)數(shù)據(jù)已準備好待處理，也可以立即通知主循環(huán)，讓它讀取數(shù)據(jù)報。

無論如何處理SIGIO信號，這種模型的優(yōu)勢在于等待數(shù)據(jù)報到達期間，進程不被阻塞，主循環(huán)可以繼續(xù)執(zhí)行，只要不時地等待來自信號處理函數(shù)的通知：既可以是數(shù)據(jù)已準備好被處理，也可以是數(shù)據(jù)報已準備好被讀取。

五、異步非阻塞模式

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

與前面的信號驅(qū)動模型的主要區(qū)別在于：信號驅(qū)動 I/O是由內(nèi)核通知我們何時可以啟動一個 I/O操作，而異步 I/O模型是由內(nèi)核通知我們 I/O操作何時完成。

先看一下它的流程：

這就是異步非阻塞模式

以read系統(tǒng)調(diào)用為例

steps：

a. 調(diào)用read;
b. read請求會立即返回，說明請求已經(jīng)成功發(fā)起了。
c. 在后臺完成讀操作這段時間內(nèi)，應(yīng)用程序可以執(zhí)行其他處理操作。
d. 當 read 的響應(yīng)到達時，就會產(chǎn)生一個信號或執(zhí)行一個基于線程的回調(diào)函數(shù)來完成這次 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);   //每次循環(huán)都要清空集合，否則不能檢測描述符變化
 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是否可讀，即是否網(wǎng)絡(luò)上有數(shù)據(jù)
  {
   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; // 必須重新設(shè)置，因為超時時間到后會將其置零

 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 100

int 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;                 
}

用戶進程發(fā)起read操作之后，立刻就可以開始去做其它的事。而另一方面，從kernel的角度，當它受到一個asynchronous read之后，首先它會立刻返回，所以不會對用戶進程產(chǎn)生任何block。然后，kernel會等待數(shù)據(jù)準備完成，然后將數(shù)據(jù)拷貝到用戶內(nèi)存，當這一切都完成之后，kernel會給用戶進程發(fā)送一個signal，告訴它read操作完成了。

六、總結(jié)

到目前為止，已經(jīng)將四個IO Model都介紹完了。

現(xiàn)在回過頭來回答兩個問題：
blocking和non-blocking的區(qū)別在哪?
synchronous IO和asynchronous IO的區(qū)別在哪。

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

前面的介紹中其實已經(jīng)很明確的說明了這兩者的區(qū)別。

調(diào)用blocking IO會一直block住對應(yīng)的進程直到操作完成，
而non-blocking IO在kernel還在準備數(shù)據(jù)的情況下會立刻返回。

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

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

復(fù)制代碼代碼如下:

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

復(fù)制代碼代碼如下:

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

兩者的區(qū)別就在于：

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

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

有人可能會說，non-blocking IO并沒有被block啊。這里有個非?！敖苹钡牡胤剑x中所指的”IO operation”是指真實的IO操作，就是例子中的recvfrom這個system call。

non-blocking IO在執(zhí)行recvfrom這個system call的時候，如果kernel的數(shù)據(jù)沒有準備好，這時候不會block進程。

但是，當kernel中數(shù)據(jù)準備好的時候，recvfrom會將數(shù)據(jù)從kernel拷貝到用戶內(nèi)存中，這個時候進程是被block了，在這段時間內(nèi)，進程是被block的。

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

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

經(jīng)過上面的介紹，會發(fā)現(xiàn)non-blocking IO和asynchronous IO的區(qū)別還是很明顯的:

在non-blocking IO中，雖然進程大部分時間都不會被block，但是它仍然要求進程去主動的check，并且當數(shù)據(jù)準備完成以后，也需要進程主動的再次調(diào)用recvfrom來將數(shù)據(jù)拷貝到用戶內(nèi)存。

而asynchronous IO則完全不同。它就像是用戶進程將整個IO操作交給了他人（kernel）完成，然后他人做完后發(fā)信號通知。在此期間，用戶進程不需要去檢查IO操作的狀態(tài)，也不需要主動的去拷貝數(shù)據(jù)。

最后，再舉幾個不是很恰當?shù)睦觼碚f明這五個IO Model:

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

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

以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: