linux 的 Socket IO 模型
前言
之前有看到用很幽默的方式講解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 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都是同步阻塞工作模式,
在結果沒有返回時,程序什麼也不做。
這種模型非常經典,也被廣泛使用。
優勢在於非常簡單,等待的過程中佔用的系統資源微乎其微,程序調用返回時,必定可以拿到數據;
但簡單也帶來一些缺點,程序在數據到來並準備好以前,不能進行其他操作,
需要有一個線程專門用於等待,這種代價對於需要處理大量連接的服務器而言,是很難接受的。
二、同步非阻塞模型
收到平安信後,老陳稍稍放心了,就不再一直在收發室前等信;
而是每隔一段時間就去收發室檢查信箱;
這樣,老陳也能在間隔時間內休息一會,或喝杯荼,看會電視,做點別的事情;
這就是同步非阻塞模型;
同步阻塞 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 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;
}
這種模式在沒有數據可以接收時,可以進行其他的一些操作,
比如有多個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實現,它的工作流程如下圖:
圖3
用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操作何時完成 。
先看一下它的流程:
圖5:
這就是異步非阻塞模式
以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 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;
}
用戶進程發起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的比較如圖所示:
圖6
經過上面的介紹,會發現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發個短信。
之前有看到用很幽默的方式講解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 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都是同步阻塞工作模式,
在結果沒有返回時,程序什麼也不做。
這種模型非常經典,也被廣泛使用。
優勢在於非常簡單,等待的過程中佔用的系統資源微乎其微,程序調用返回時,必定可以拿到數據;
但簡單也帶來一些缺點,程序在數據到來並準備好以前,不能進行其他操作,
需要有一個線程專門用於等待,這種代價對於需要處理大量連接的服務器而言,是很難接受的。
二、同步非阻塞模型
收到平安信後,老陳稍稍放心了,就不再一直在收發室前等信;
而是每隔一段時間就去收發室檢查信箱;
這樣,老陳也能在間隔時間內休息一會,或喝杯荼,看會電視,做點別的事情;
這就是同步非阻塞模型;
同步阻塞 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 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;
}
這種模式在沒有數據可以接收時,可以進行其他的一些操作,
比如有多個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實現,它的工作流程如下圖:
圖3
用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操作何時完成 。
先看一下它的流程:
圖5:
這就是異步非阻塞模式
以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 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;
}
用戶進程發起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的比較如圖所示:
圖6
經過上面的介紹,會發現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發個短信。
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.