一.5种I/O模型
一个I/O可以分为两个过程:等待和数据搬迁。
1.阻塞I/O
两个过程都有自己来完成，其他什么事也不做。
2.非阻塞I/O
在等的过程中可以干一些其他的事，等到数据准备好再进行搬迁
3.信号驱动I/O
等数据准备好的过程由信号来触发，在这期间自己可以干一些别的事
4.I/O复用
同时阻塞多个I/O操作，谁数据准备好就对其进行数据搬迁。
5.异步I/O
将任务派发，不用自己来完成。完成之后通知自己就行。
二.高级I/O
非阻塞IO，纪录锁，系统V流机制，I/O多路转接（select/poll）,readv和writev函数以及存储映射IO（mmap），这些统称为高级IO。
1.socketpair
pipe用来创建管道，但是单个管道只能单向通信，一端用于读，而另一端用于写。如果要实现进程双向通信，必须创建一对管道。而socketpair则可以用来创建双向通信的管道，具体实现如下：
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, int sv[2]);
domain：域 type：传输类型 protocol：协议类型，
创建父子进程，让子进程关闭读，父关闭写，然后双方发送消息
1 #include<stdio.h>
2 #include<errno.h>
3 #include<unistd.h>
4 #include<stdlib.h>
5 #include<string.h>
6 #include<sys/socket.h>
7 #include<sys/types.h>
8 int main()
9 {
10 int sv[2]={0,0};
11 int sock=socketpair(AF_LOCAL,SOCK_STREAM,0,sv);
12 if(sock<0)
13 {
14 perror("socketpair");
15 exit(1);
16 }
17 pid_t id=fork();
19 if(id<0)
20 {
21 perror("fork");
22 exit(2);
23 }
24 else if(id==0)
25 {
26 close (sv[0]);//读关闭
27 char buf[1024];
28 while(1)
29 {
30 memset(buf,‘\0‘,sizeof(buf));
31 strcpy(buf,"hello bit");
32 write(sv[1],buf,sizeof(buf)-1);
33 ssize_t size=read(sv[1],buf,sizeof(buf)-1);
34 buf[size]=‘\0‘;
36 sleep(1);
37
38 printf("father->child: %s\n",buf);
39 }
40 }
41 else
42 {
43 close (sv[1]);//写关闭
44 char buf[1024];
45 while(1)
46 {
47 ssize_t size=read(sv[0],buf,sizeof(buf)-1);
48 buf[size]=‘\0‘;
49 printf("child-> father: %s\n",buf);
50 strcpy(buf,"hello");
51 write(sv[0],buf,sizeof(buf));
52 //sleep(2);
53 }
54 }
55
56 return 0;
57 }
程序结果：
2.dup/dup2对输入文件描述符重定向
dup将标准输出重定向当前旧的且不用的最小文件描述符。
dup2将old文件描述符指向的内容复制到new，两者指向同一文件
dup代码：
1 #include<stdio.h>
2 //#define _OPEN_FILE_ "./log"
3 #include<unistd.h>
4 #include<sys/types.h>
5 #include<fcntl.h>
6 #include<sys/stat.h>
7 #include<unistd.h>
8 int main()
9 {
10 umask(0);
11 int fd=open("./log",O_CREAT|O_RDWR);
12 if(fd<0)
13 {
14 printf("open");
15 exit(1);
16
17 }
18 close(1);
19 int new_fd=dup(fd）;
20 close(fd);
23 int count=1;
24 while(count++<10)
25 {
26
27 printf("hello bit\n");
28 fflush(stdout);
29 }
31 close(new_fd);
33 return 0;
34 }
程序结果:
dup2代码：
8 int main()
9 {
10 umask(0);
11 int fd=open("./log",O_CREAT|O_RDWR);
12 if(fd<0)
13 {
14 printf("open");
15 exit(1);
16
17 }
18 close(1);
19 int ret=dup2(fd,1）;
20
23 int count=1;
24 while(count++<10)
25 {
26
27 printf("hello bit\n");
28 fflush(stdout);
29 }
31 close(fd);
33 return 0;
34 }
3.I/O多路转接之select
系统提供select函数来实现多路复用输入/输出模型。select系统调用来让我们的程序监视
个句柄的状态变化，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
参数nfds是需要监视的最大的文件描述符值+1；
rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合。
struct timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0。
下面的宏提供了处理这三种描述词组的方式:
FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位
FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真
FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位
FD_ZERO（fd_set *set）；用来清除描述词组set的全部位
参数timeout为结构timeval，用来设置select()的等待时间，其结构定义如下：
如果参数timeout设为：
NULL：则表示select（）没有timeout，select将一直被阻塞，直到某个文件描述符上发生了
事件。
0：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生。
特定的时间值：如果在指定的时间段里没有事件发生，select将超时返回。
理解select模型：
理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。
（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)
（3）若再加入fd＝2，fd=1,则set变为0001,0011
（4）执行select(6,&set,0,0,0)阻塞等待
（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。
基于上面的讨论，可以轻松得出select模型的特点：
（1)可监控的文件描述符个数取决与sizeof(fd_set)的值。我这边服务 器上sizeof(fd_set)＝512，每bit表示一个文件描述符，则我服务器上支持的最大文件描述符是512*8=4096。据说可调，另有说虽 然可调，但调整上限受于编译内核时的变量值。
（2）将fd加入select监控集的同时，还要再使用一个数据结构array保存放到select监控集中的fd，一是用于再select 返回后，array作为源数据和fd_set进行FD_ISSET判断。二是select返回后会把以前加入的但并无事件发生的fd清空，则每次开始 select前都要重新从array取得fd逐一加入（FD_ZERO最先），扫描array的同时取得fd最大值maxfd，用于select的第一个 参数。
（3）可见select模型必须在select前循环array（加fd，取maxfd），select返回后循环array
（FD_ISSET判断是否有时间发生）。
1>select使用事例，检测标准输入输出代码：
1 #include<stdio.h>>
2 #include<unistd.h>
3 #include<errno.h>
4 #include<stdlib.h>
5 #include<string.h>
6 #include<sys/select.h>
7
8 int main()
9 {
10 int std_in=0;//标准输入
11 //int std_out=1;//标准输出
12 int max_fd=0;
13 struct timeval timeout={2,0};//超时
14 fd_set reads;//定义文件描述符集
15 //fd_set writes;
16 FD_ZERO(&reads); //初始化
17 //FD_ZERO(&writes);
18 FD_SET(std_in,&reads);//站在应用程序的角度来看关心什么事件
19 //FD_SET(std_out,&writes);
20 while(1)
21 {
22 timeout.tv_sec=2;
23 timeout.tv_usec=0;
24 FD_ZERO(&reads); //重新设置
25 // FD_ZERO(&writes);
26 FD_SET(std_in,&reads);
27 //FD_SET(std_out,&writes);
28 switch(select((max_fd+1),&reads,NULL,NULL,&timeout))
29 {
30 case -1://biaoshichucuo
31 perror("select");
32 break;
33 case 0://chaoshi
34 printf("select timeout....\n");
35 break;
36 default://zhengchang
37 {//panduanshuijiuxu
38 if(FD_ISSET(std_in,&reads))
39 {
40 char buf[1024];
41 memset(buf,‘\0‘,sizeof(buf));
42 ssize_t size=read(std_in,buf,strlen(buf));
43 if(size>0)//duquchenggong
44 {
45 buf[size]=‘\0‘;
46 printf("%s\n",buf);
47 }
48 }
49 // if(FD_ISSET(std_out,&writes))
50 //{
51 // printf("hello\n");
52
53 // }
54 }
55 break;
56
57 }
58 }
59 return 0;
60 }
程序中剥离write的事件，程序结果会打印过上timeout时间之后打印select timeout，
若将write放开，则会一直打印消息。因为写一直就绪。
2>select使用事例select编写网络服务器代码
//select_server.c
1 #include<stdio.h>
2 #include<sys/select.h>
3 #include<sys/socket.h>
4 #include<errno.h>
5 #include<string.h>
6 #include<arpa/inet.h>
7 #include<netinet/in.h>
8 #include<stdlib.h>
9 #include<sys/types.h>
10 int fds[64];//yongshuzubaocunwenjianmaioshufuji
11 static void usage(char* proc)
12 {
13 printf("usage: %s [ip] [port]",proc);
14 }
15
16 static int start(int port,char *ip)
17 {
18 int sock=socket(AF_INET,SOCK_STREAM,0);
19 if(sock<0)
20 {
21 perror("socket");
22 exit(1);
23 }
24 struct sockaddr_in local;
25 local.sin_family=AF_INET;
26 local.sin_port=htons(port);
27 local.sin_addr.s_addr=inet_addr(ip);
28 if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
29 {
30 perror("bind");
31 exit(1);
32 }
33 if(listen(sock,5)<0)
34 {
35 perror("listen");
36 exit(1);
37 }
38 return sock;
39
40
41 }
42 int main(int argc,char*argv[])
43 {
44 if(argc!=3)
45 {
46 usage(argv[0]);
47 return 1;
48 }
49 int port=atoi(argv[2]);
50 char* ip=argv[1];
51 int listen_sock=start(port,ip);
52 int new_sock=-1;
53 struct sockaddr_in client;
54 socklen_t len=sizeof(client);
55 int max_fd=0;
56 fd_set reads;//dingyiwenjianmiaoshufuji
57 fd_set writes;
58 FD_ZERO(&reads);
59 FD_ZERO(&writes);
60 FD_SET(listen_sock,&reads);
61 struct timeval timeout={15,0};
62 int fds_num=sizeof(fds)/sizeof(fds[0]);
63 int i=0;
64 for(;i<fds_num;++i)
65 {
66 fds[i]=-1;
67 }
68 fds[0]=listen_sock;
69 max_fd=fds[0];
70 while(1)
71 {
72 timeout.tv_sec=15;
73 timeout.tv_usec=0;
74 FD_ZERO(&reads);
75 FD_ZERO(&writes);
76 FD_SET(listen_sock,&reads);
77
78 for(i=1;i<fds_num;++i)
79 {
80 if(fds[i]>0)
81 {
82 FD_SET(fds[i],&reads);
83 if(fds[i]>max_fd)
84 {
85 max_fd=fds[i];
86 }
87 }
88 }
89 switch(select(max_fd+1,&reads,NULL,NULL,&timeout))
90 {
91 case -1:// 出错
92 perror("select");
93 break;
94 case 0://超时
95 printf("select timeout......\n");
96 break;
97 default://正常
98 {
99 for(i=0;i<fds_num;++i)
100 {//当为listen_sock
101 if(fds[i]==listen_sock&&FD_ISSET(fds[i],&reads))
102 { //接收连接请求
103 new_sock=accept(listen_sock,(struct sockaddr*)&client,&l en);
104 if(new_sock<0)
105 {
106 perror("accept");
107 continue;
108 }
109 printf("get connect........\n");
110 for(i=0;i<fds_num;++i)
111 {
112 if(fds[i]==-1)
113 {
114 fds[i]=new_sock;
115 break;
116 }
117 }
118 if(i==fds_num)
119 {
120 close(new_sock);
121 }
122 }
//break
123 else if(fds[i]>0&&FD_ISSET(fds[i],&reads))
124 {
125 char buf[1024];
126 memset(buf,‘\0‘,sizeof(buf));
127 ssize_t size=read(fds[i],buf,sizeof(buf)-1);
128 if(size>0)
129 {
130 buf[size]=‘\0‘;
131 printf("client#: %s",buf);
132 write(fds[i],buf,size);
133 }
134 else if(size==0)
135 {
136 close(fds[i]);
137 fds[i]=-1;//取到文件描述符将其置为无效
138
139 }
140 }
141 }
142 }
143 break;
144
145 }
146 }
147 return 0;
148 }
//select_client.c
1 #include<stdio.h>
2 #include<sys/select.h>
3 #include<sys/socket.h>
4 #include<errno.h>
5 #include<string.h>
6 #include<arpa/inet.h>
7 #include<netinet/in.h>
8 #include<sys/types.h>
9 #include<stdlib.h>
10
11 //int fds[64];//yongshuzubaocunwenjianmaioshufuji
12 static void usage(char* proc)
13 {
14 printf("usage: %s [ip] [port]",proc);
15 }
16
17 int main(int argc,char *argv[])
18 {
19 if(argc!=3)
20 {
21 usage(argv[0]);
22 return 1;
23 }
24 int port=atoi(argv[2]);
25 char* ip=argv[1];
26 int sock=socket(AF_INET,SOCK_STREAM,0);
27 if(sock<0)
28 {
29 perror("socket");
30 exit(1);
31 }
32 struct sockaddr_in remote;
33 remote.sin_family=AF_INET;
34 remote.sin_port=htons(port);
35 remote.sin_addr.s_addr=inet_addr(ip);
36 int ret=connect(sock,(struct sockaddr*)&remote,sizeof(remote));
37 if(ret<0)
38 {
39 perror("connect");
40 exit(2);
41 }
42 char buf[1024];
43 while(1)
44 {
45 memset(buf,‘\0‘,sizeof(buf));
46 printf("please input: ");
47 fflush(stdout);
48 ssize_t s=read(0,buf,sizeof(buf)-1);
49
50 if(s>0)
51 { //回显消息
52 write(sock,buf,strlen(buf));
53 printf("server->client: %s\n",buf);
54 }
55 }
56
57 return 0;
58 }
程序结果：
select缺点：
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
（3）select支持的文件描述符数量太小了，默认是1024