Linux的Socket IO模型趣解
前言
之前有看到用很幽默的方式講解Windows的socket IO模型，借用這個(gè)故事，講解下linux的socket IO模型；
老陳有一個(gè)在外地工作的女兒，不能經(jīng)?；貋?lái)，老陳和她通過(guò)信件聯(lián)系。
他們的信會(huì)被郵遞員投遞到他們小區(qū)門(mén)口的收發(fā)室里。這和Socket模型非常類(lèi)似。
下面就以老陳接收信件為例講解linux的 Socket I/O模型。
一、同步阻塞模型
老陳的女兒第一次去外地工作，送走她之后，老陳非常的掛心她安全到達(dá)沒(méi)有；
于是老陳什么也不干，一直在小區(qū)門(mén)口收發(fā)室里等著她女兒的報(bào)平安的信到；
這就是linux的同步阻塞模式；
在這個(gè)模式中，用戶(hù)空間的應(yīng)用程序執(zhí)行一個(gè)系統(tǒng)調(diào)用，并阻塞，直到系統(tǒng)調(diào)用完成為止(數(shù)據(jù)傳輸完成或發(fā)生錯(cuò)誤)。
Socket設(shè)置為阻塞模式，當(dāng)socket不能立即完成I/O操作時(shí)，進(jìn)程或線(xiàn)程進(jìn)入等待狀態(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é)果沒(méi)有返回時(shí)，程序什么也不做。
這種模型非常經(jīng)典，也被廣泛使用。
優(yōu)勢(shì)在于非常簡(jiǎn)單，等待的過(guò)程中占用的系統(tǒng)資源微乎其微，程序調(diào)用返回時(shí)，必定可以拿到數(shù)據(jù)；但簡(jiǎn)單也帶來(lái)一些缺點(diǎn)，程序在數(shù)據(jù)到來(lái)并準(zhǔn)備好以前，不能進(jìn)行其他操作，需要有一個(gè)線(xiàn)程專(zhuān)門(mén)用于等待，這種代價(jià)對(duì)于需要處理大量連接的服務(wù)器而言，是很難接受的。
二、同步非阻塞模型
收到平安信后，老陳稍稍放心了，就不再一直在收發(fā)室前等信，而是每隔一段時(shí)間就去收發(fā)室檢查信箱，這樣，老陳也能在間隔時(shí)間內(nèi)休息一會(huì)，或喝杯荼，看會(huì)電視，做點(diǎn)別的事情，這就是同步非阻塞模型。
同步阻塞 I/O 的一種效率稍低的變種是同步非阻塞 I/O，在這種模型中，系統(tǒng)調(diào)用是以非阻塞的形式打開(kāi)的，這意味著 I/O 操作不會(huì)立即完成， 操作可能會(huì)返回一個(gè)錯(cuò)誤代碼，說(shuō)明這個(gè)命令不能立即滿(mǎn)足（EAGAIN 或 EWOULDBLOCK），非阻塞的實(shí)現(xiàn)是 I/O 命令可能并不會(huì)立即滿(mǎn)足，需要應(yīng)用程序調(diào)用許多次來(lái)等待操作完成。
這可能效率不高，因?yàn)樵诤芏嗲闆r下，當(dāng)內(nèi)核執(zhí)行這個(gè)命令時(shí)，應(yīng)用程序必須要進(jìn)行忙碌等待，直到數(shù)據(jù)可用為止，或者試圖執(zhí)行其他工作。因?yàn)閿?shù)據(jù)在內(nèi)核中變?yōu)榭捎玫接脩?hù)調(diào)用 read 返回?cái)?shù)據(jù)之間存在一定的間隔，這會(huì)導(dǎo)致整體數(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;
}
這種模式在沒(méi)有數(shù)據(jù)可以接收時(shí)，可以進(jìn)行其他的一些操作，比如有多個(gè)socket時(shí)，可以去查看其他socket有沒(méi)有可以接收的數(shù)據(jù)；實(shí)際應(yīng)用中，這種I/O模型的直接使用并不常見(jiàn)，因?yàn)樗枰煌５牟樵?xún)，而這些查詢(xún)大部分會(huì)是無(wú)必要的調(diào)用，白白浪費(fèi)了系統(tǒng)資源；非阻塞I/O應(yīng)該算是一個(gè)鋪墊，為I/O復(fù)用和信號(hào)驅(qū)動(dòng)奠定了非阻塞使用的基礎(chǔ)。
我們可以使用 fcntl(fd, F_SETFL, flag | O_NONBLOCK);將套接字標(biāo)志變成非阻塞，調(diào)用recv，如果設(shè)備暫時(shí)沒(méi)有數(shù)據(jù)可讀就返回-1，同時(shí)置errno為EWOULDBLOCK（或者EAGAIN，這兩個(gè)宏定義的值相同），表示本來(lái)應(yīng)該阻塞在這里（would block，虛擬語(yǔ)氣），事實(shí)上并沒(méi)有阻塞而是直接返回錯(cuò)誤，調(diào)用者應(yīng)該試著再讀一次（again）。
這種行為方式稱(chēng)為輪詢(xún)（Poll），調(diào)用者只是查詢(xún)一下，而不是阻塞在這里死等，這樣可以同時(shí)監(jiān)視多個(gè)設(shè)備：
while(1)
{
非阻塞read(設(shè)備1);
if(設(shè)備1有數(shù)據(jù)到達(dá))
處理數(shù)據(jù);
非阻塞read(設(shè)備2);
if(設(shè)備2有數(shù)據(jù)到達(dá))
處理數(shù)據(jù);
…………………………
}
如果read(設(shè)備1)是阻塞的，那么只要設(shè)備1沒(méi)有數(shù)據(jù)到達(dá)就會(huì)一直阻塞在設(shè)備1的read調(diào)用上，即使設(shè)備2有數(shù)據(jù)到達(dá)也不能處理，使用非阻塞I/O就可以避免設(shè)備2得不到及時(shí)處理。非阻塞I/O有一個(gè)缺點(diǎn)，如果所有設(shè)備都一直沒(méi)有數(shù)據(jù)到達(dá)，調(diào)用者需要反復(fù)查詢(xún)做無(wú)用功，如果阻塞在那里，操作系統(tǒng)可以調(diào)度別的進(jìn)程執(zhí)行，就不會(huì)做無(wú)用功了，在實(shí)際應(yīng)用中非阻塞I/O模型比較少用
三、I/O 復(fù)用(異步阻塞)模式
頻繁地去收發(fā)室對(duì)老陳來(lái)說(shuō)太累了，在間隔的時(shí)間內(nèi)能做的事也很少，而且取到信的效率也很低.
于是，老陳向小區(qū)物業(yè)提了建議；
小區(qū)物業(yè)改進(jìn)了他們的信箱系統(tǒng)：
住戶(hù)先向小區(qū)物業(yè)注冊(cè)，之后小區(qū)物業(yè)會(huì)在已注冊(cè)的住戶(hù)的家中添加一個(gè)提醒裝置，每當(dāng)有注冊(cè)住房的新的信件來(lái)臨，此裝置會(huì)發(fā)出 “新信件到達(dá)”聲，提醒老陳去看是不是自己的信到了。這就是異步阻塞模型。
在這種模型中，配置的是非阻塞 I/O，然后使用阻塞 select 系統(tǒng)調(diào)用來(lái)確定一個(gè) I/O 描述符何時(shí)有操作。使 select 調(diào)用非常有趣的是它可以用來(lái)為多個(gè)描述符提供通知，而不僅僅為一個(gè)描述符提供通知。對(duì)于每個(gè)提示符來(lái)說(shuō)，我們可以請(qǐng)求這個(gè)描述符可以寫(xiě)數(shù)據(jù)、有讀數(shù)據(jù)可用以及是否發(fā)生錯(cuò)誤的通知
I/O復(fù)用模型能讓一個(gè)或多個(gè)socket可讀或可寫(xiě)準(zhǔn)備好時(shí)，應(yīng)用能被通知到；
I/O復(fù)用模型早期用select實(shí)現(xiàn)，它的工作流程如下圖：
用select來(lái)管理多個(gè)I/O，當(dāng)沒(méi)有數(shù)據(jù)時(shí)select阻塞，如果在超時(shí)時(shí)間內(nèi)數(shù)據(jù)到來(lái)則select返回，再調(diào)用recv進(jìn)行數(shù)據(jù)的復(fù)制，recv返回后處理數(shù)據(jù)。
下面的C語(yǔ)言實(shí)現(xiàn)的例子，它從網(wǎng)絡(luò)上接受數(shù)據(jù)寫(xiě)入一個(gè)文件中:
/*
* \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秒輪詢(xún)
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)都要清空集合，否則不能檢測(cè)描述符變化
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)) //測(cè)試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實(shí)現(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();
四、信號(hào)驅(qū)動(dòng) I/O 模型
老陳接收到新的信件后，一般的程序是：
打開(kāi)信封—-掏出信紙 —-閱讀信件—-回復(fù)信件 ……為了進(jìn)一步減輕用戶(hù)負(fù)擔(dān)，小區(qū)物業(yè)又開(kāi)發(fā)了一種新的技術(shù)：住戶(hù)只要告訴小區(qū)物業(yè)對(duì)信件的操作步驟，小區(qū)物業(yè)信箱將按照這些步驟去處理信件，不再需要用戶(hù)親自拆信 /閱讀/回復(fù)了！這就是信號(hào)驅(qū)動(dòng)I/O模型。
我們也可以用信號(hào)，讓內(nèi)核在描述字就緒時(shí)發(fā)送SIGIO信號(hào)通知我們。
首先開(kāi)啟套接口的信號(hào)驅(qū)動(dòng) I/O功能，并通過(guò)sigaction系統(tǒng)調(diào)用安裝一個(gè)信號(hào)處理函數(shù)。該系統(tǒng)調(diào)用將立即返回，我們的進(jìn)程繼續(xù)工作，也就是說(shuō)沒(méi)被阻塞。當(dāng)數(shù)據(jù)報(bào)準(zhǔn)備好讀取時(shí)，內(nèi)核就為該進(jìn)程產(chǎn)生一個(gè)SIGIO信號(hào)，我們隨后既可以在信號(hào)處理函數(shù)中調(diào)用recvfrom讀取數(shù)據(jù)報(bào)，并通知主循環(huán)數(shù)據(jù)已準(zhǔn)備好待處理，也可以立即通知主循環(huán)，讓它讀取數(shù)據(jù)報(bào)。
無(wú)論如何處理SIGIO信號(hào)，這種模型的優(yōu)勢(shì)在于等待數(shù)據(jù)報(bào)到達(dá)期間，進(jìn)程不被阻塞，主循環(huán)可以繼續(xù)執(zhí)行，只要不時(shí)地等待來(lái)自信號(hào)處理函數(shù)的通知：既可以是數(shù)據(jù)已準(zhǔn)備好被處理，也可以是數(shù)據(jù)報(bào)已準(zhǔn)備好被讀取。
五、異步非阻塞模式
linux下的asynchronous IO其實(shí)用得很少。
與前面的信號(hào)驅(qū)動(dòng)模型的主要區(qū)別在于：信號(hào)驅(qū)動(dòng) I/O是由內(nèi)核通知我們何時(shí)可以啟動(dòng)一個(gè) I/O操作，而異步 I/O模型是由內(nèi)核通知我們 I/O操作何時(shí)完成 。
先看一下它的流程：
這就是異步非阻塞模式
以read系統(tǒng)調(diào)用為例
steps：
a. 調(diào)用read;
b. read請(qǐng)求會(huì)立即返回，說(shuō)明請(qǐng)求已經(jīng)成功發(fā)起了。
c. 在后臺(tái)完成讀操作這段時(shí)間內(nèi)，應(yīng)用程序可以執(zhí)行其他處理操作。
d. 當(dāng) read 的響應(yīng)到達(dá)時(shí)，就會(huì)產(chǎn)生一個(gè)信號(hào)或執(zhí)行一個(gè)基于線(xiàn)程的回調(diào)函數(shù)來(lái)完成這次 I/O 處理過(guò)程。
/*
* \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秒輪詢(xún)
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)都要清空集合，否則不能檢測(cè)描述符變化
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)) //測(cè)試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è)置，因?yàn)槌瑫r(shí)時(shí)間到后會(huì)將其置零
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;
}
用戶(hù)進(jìn)程發(fā)起read操作之后，立刻就可以開(kāi)始去做其它的事。而另一方面，從kernel的角度，當(dāng)它受到一個(gè)asynchronous read之后，首先它會(huì)立刻返回，所以不會(huì)對(duì)用戶(hù)進(jìn)程產(chǎn)生任何block。然后，kernel會(huì)等待數(shù)據(jù)準(zhǔn)備完成，然后將數(shù)據(jù)拷貝到用戶(hù)內(nèi)存，當(dāng)這一切都完成之后，kernel會(huì)給用戶(hù)進(jìn)程發(fā)送一個(gè)signal，告訴它read操作完成了。
六、總結(jié)
到目前為止，已經(jīng)將四個(gè)IO Model都介紹完了。
現(xiàn)在回過(guò)頭來(lái)回答兩個(gè)問(wèn)題：
blocking和non-blocking的區(qū)別在哪?
synchronous IO和asynchronous IO的區(qū)別在哪。
先回答最簡(jiǎn)單的這個(gè)：blocking vs non-blocking。
前面的介紹中其實(shí)已經(jīng)很明確的說(shuō)明了這兩者的區(qū)別。
調(diào)用blocking IO會(huì)一直block住對(duì)應(yīng)的進(jìn)程直到操作完成，
而non-blocking IO在kernel還在準(zhǔn)備數(shù)據(jù)的情況下會(huì)立刻返回。
在說(shuō)明synchronous IO和asynchronous IO的區(qū)別之前，需要先給出兩者的定義。
Stevens給出的定義（其實(shí)是POSIX的定義）是這樣子的：
兩者的區(qū)別就在于：
synchronous IO做”IO operation”的時(shí)候會(huì)將process阻塞。
按照這個(gè)定義，之前所述的blocking IO，non-blocking IO，IO multiplexing都屬于synchronous IO。
有人可能會(huì)說(shuō)，non-blocking IO并沒(méi)有被block啊。這里有個(gè)非?！敖苹钡牡胤剑x中所指的”IO operation”是指真實(shí)的IO操作，就是例子中的recvfrom這個(gè)system call。
non-blocking IO在執(zhí)行recvfrom這個(gè)system call的時(shí)候，如果kernel的數(shù)據(jù)沒(méi)有準(zhǔn)備好，這時(shí)候不會(huì)block進(jìn)程。
但是，當(dāng)kernel中數(shù)據(jù)準(zhǔn)備好的時(shí)候，recvfrom會(huì)將數(shù)據(jù)從kernel拷貝到用戶(hù)內(nèi)存中， 這個(gè)時(shí)候進(jìn)程是被block了，在這段時(shí)間內(nèi)，進(jìn)程是被block的。
而asynchronous IO則不一樣，當(dāng)進(jìn)程發(fā)起IO 操作之后，就直接返回再也不理睬了，直到kernel發(fā)送一個(gè)信號(hào)，告訴進(jìn)程說(shuō)IO完成。在這整個(gè)過(guò)程中，進(jìn)程完全沒(méi)有被block。
各個(gè)IO Model的比較如圖所示：
經(jīng)過(guò)上面的介紹，會(huì)發(fā)現(xiàn)non-blocking IO和asynchronous IO的區(qū)別還是很明顯的:
在non-blocking IO中，雖然進(jìn)程大部分時(shí)間都不會(huì)被block，但是它仍然要求進(jìn)程去主動(dòng)的check，并且當(dāng)數(shù)據(jù)準(zhǔn)備完成以后，也需要進(jìn)程主動(dòng)的再次調(diào)用recvfrom來(lái)將數(shù)據(jù)拷貝到用戶(hù)內(nèi)存。
而asynchronous IO則完全不同。它就像是用戶(hù)進(jìn)程將整個(gè)IO操作交給了他人（kernel）完成，然后他人做完后發(fā)信號(hào)通知。在此期間，用戶(hù)進(jìn)程不需要去檢查IO操作的狀態(tài)，也不需要主動(dòng)的去拷貝數(shù)據(jù)。
最后，再舉幾個(gè)不是很恰當(dāng)?shù)睦觼?lái)說(shuō)明這五個(gè)IO Model:
有A，B，C，D，E五個(gè)人釣魚(yú)：
A用的是最老式的魚(yú)竿，所以呢，得一直守著，等到魚(yú)上鉤了再拉桿；
B的魚(yú)竿有個(gè)功能，能夠顯示是否有魚(yú)上鉤，所以呢，B就和旁邊的MM聊天，隔會(huì)再看看有沒(méi)有魚(yú)上鉤，有的話(huà)就迅速拉桿；
C用的魚(yú)竿和B差不多，但他想了一個(gè)好辦法，就是同時(shí)放好幾根魚(yú)竿，然后守在旁邊，一旦有顯示說(shuō)魚(yú)上鉤了，它就將對(duì)應(yīng)的魚(yú)竿拉起來(lái)；
D是個(gè)有錢(qián)人，他沒(méi)耐心等， 但是又喜歡釣上魚(yú)的快感，所以雇了個(gè)人，一旦那個(gè)人發(fā)現(xiàn)有魚(yú)上鉤，就會(huì)通知D過(guò)來(lái)把魚(yú)釣上來(lái)；
E也是個(gè)有錢(qián)人，干脆雇了一個(gè)人幫他釣魚(yú)，一旦那個(gè)人把魚(yú)釣上來(lái)了，就給E發(fā)個(gè)短信。
以上就是本文的全部?jī)?nèi)容，希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
在Linux命令行中使用計(jì)算器的5個(gè)命令詳解
這篇文章主要介紹了在Linux命令行中使用計(jì)算器的5個(gè)命令,本文給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2020-08-08
本篇文章主要介紹了Linux netstat命令詳解，現(xiàn)在分享給大家，也留給日后一個(gè)參考，有需要的可以了解一下。2016-11-11
這篇文章主要介紹了Linux安裝CUDA GCC版本不兼容問(wèn)題,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2024-02-02
這篇文章主要介紹了linux設(shè)置hosts全過(guò)程，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2023-07-07
眾所周知，linux是沒(méi)有回收站的，一些人很害怕刪錯(cuò)東西（有經(jīng)驗(yàn)的linux管理員極少范這錯(cuò)誤），個(gè)人不建議回收站，而應(yīng)該是培養(yǎng)個(gè)人的安全意識(shí)。有點(diǎn)小跑題2016-08-08
Linux用戶(hù)管理與常見(jiàn)權(quán)限命令
在Linux系統(tǒng)中,用戶(hù)和組是管理權(quán)限和資源訪(fǎng)問(wèn)的基本單元,用戶(hù)可以屬于一個(gè)或多個(gè)組,組用于集中管理一組用戶(hù)的權(quán)限,文件權(quán)限決定了用戶(hù)或組對(duì)文件的訪(fǎng)問(wèn)級(jí)別,每個(gè)文件或目錄都有三個(gè)權(quán)限集,分別適用于文件所有者（User）、所屬組（Group）和其他用戶(hù)（Others）2024-08-08
詳解Linux系統(tǒng)三種模式下的簡(jiǎn)單命令
這篇文章主要介紹了Linux系統(tǒng)三種模式下的簡(jiǎn)單命令，非常不錯(cuò)，具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2018-07-07
本篇文章主要介紹了ubuntu如何安裝中文輸入法，小編覺(jué)得挺不錯(cuò)的，現(xiàn)在分享給大家，也給大家做個(gè)參考。一起跟隨小編過(guò)來(lái)看看吧2017-07-07
linux環(huán)境搭建圖數(shù)據(jù)庫(kù)neo4j的講解
今天小編就為大家分享一篇關(guān)于linux環(huán)境搭建圖數(shù)據(jù)庫(kù)neo4j的講解，小編覺(jué)得內(nèi)容挺不錯(cuò)的，現(xiàn)在分享給大家，具有很好的參考價(jià)值，需要的朋友一起跟隨小編來(lái)看看吧2019-04-04
解決ubuntu安裝軟件時(shí),status-code=409報(bào)錯(cuò)的問(wèn)題
這篇文章主要介紹了解決ubuntu安裝軟件時(shí)，status-code=409報(bào)錯(cuò)的問(wèn)題，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2022-12-12