lv6 网络编程（6）IO多路复用
目录
前言
1.IO模型
1.1阻塞IO
1.2非阻塞I/O
1.3I/O 多路复用
1.3.1 select()/poll()实现多路复用
代码演示:服务器端使用select
1.4信号驱动I/O
2.epoll的使用
总结
前言
1.IO模型
在UNIX/Linux下主要有4种I/O 模型：
阻塞I/O：最常用
非阻塞I/O：可防止进程阻塞在I/O操作上，需要轮询
I/O 多路复用：允许同时对多个I/O进行控制
信号驱动I/O: 一种异步通信模型
1.1阻塞IO
阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。
缺省情况下，套接字建立后所处于的模式就是阻塞I/O 模式。
前面学习的很多读写函数在调用过程中会发生阻塞。
读操作中的read、recv、recvfrom
写操作中的write、send
其他操作：accept、connect注意:sendto函数不是阻塞函数,这是因为UDP协议的特殊性
1.1.1读阻塞
以read函数为例：
进程调用read函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read将发生阻塞。
它会一直阻塞下去，等待套接字的接收缓冲区中有数据可读。
经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过read访问这些数据。
如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去。
1.1.2写阻塞
在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
这时，写操作不进行任何拷贝工作，将发生阻塞。
一量发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。
UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞。
1.2非阻塞I/O
当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”
当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。
应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
这种模式使用中不普遍。
fcntl()函数 -- 非阻塞实现
当你一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞IO模式。
可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
代码实现；
1.fcntl( )函数int fcntl(int fd, int cmd, long arg);
int flag；
flag = fcntl(sockfd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(sockfd, F_SETFL, flag);
2.ioctl() 函数
int b_on =1;
ioctl(sock_fd, FIONBIO, &b_on);
1.3I/O 多路复用
应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；
linux每个进程在默认情况下，最多打开1024个文件，最多有1024个文件描述符。
多路复用针对的不止套接字fd，也包括普通文件描述fd。
文件描述符特点：
1.非负整数
2.从最小可以数字来分配
3.每个进程启动时默认打开0,1,2三个文件描述符
比较好的方法是使用I/O多路复用。其基本思想是：
先构造一张有关描述符的表，然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。
1.3.1 select()/poll()实现多路复用
#include
#include
#include
int select(int n, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);
maxfd
所有监控的文件描述符中最大的那一个加1
read_fds
所有要读的文件文件描述符的集合
write_fds
所有要的写文件文件描述符的集合
except_fds
其他要向我们通知的文件描述符
timeout
超时设置.
Null：一直阻塞，直到有文件描述符就绪或出错
时间值为0：仅仅检测文件描述符集的状态，然后立即返回
时间值不为0：在指定时间内，如果没有事件发生，则超时返回。
select执行流程:
1.把关心文件描述符放入到集合中(fd_set)
2.调用select()/poll()函数去监控集合fd_set中哪些文件描述符(阻塞等待集合中一个或多个文件描述有数据)
3.当有数据时,退出select()阻塞
4.依次判断哪个文件描述有数据
5.依次处理有数据的文件描述符的数据
在我们调用select时进程会一直阻塞直到以下的一种情况发生.
有文件可以读.
有文件可以写.
超时所设置的时间到.
为了设置文件描述符我们要使用几个宏：
FD_SET 将fd加入到fdset
FD_CLR 将fd从fdset里面清除
FD_ZERO 从fdset中清除所有的文件描述符
FD_ISSET 判断fd是否在fdset集合中
宏的形式:
void FD_ZERO(fd_set *fdset)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)
关键点：
1. select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化：
前：表示关心的文件描述符集合
后：有数据的集合（如不是在超时还回情况下）2. 那么究竟是谁动了fd_set集合的奶酪？
答曰：kernel
思考： 这种模式下，多路网络连接时候能否真正多路并发处理？如果能，请说明理由，如不能，请给出改进意见
#include
int poll(struct pollfd *ufds, unsigned int nfds, int timeout);
代码演示:服务器端使用select
1.server端
#include "net.h"
#include
void* childProcesstest(void*);
void handler(int arg){
if(SIGCHLD == arg){//触发回收子进程
waitpid(-1,NULL,WNOHANG);
}
}
int main(int argc, const char *argv[])
{
int fd;
struct sockaddr_in sin;
//signal(SIGCHLD,handler);
//1.创建socket fd
fd = socket(AF_INET,SOCK_STREAM,0);
if(fd < 0){
perror("socket");
exit(0);
}
/*优化4： 允许绑定地址快速重用 */
int b_reuse = 10;
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
//2.bind函数
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT);
//优化1
#if 0
sin.sin_addr.s_addr = htonl(INADDY_ANY);
#else
if(inet_pton(AF_INET,SERV_IP_ADDR,&sin.sin_addr)< 0){
perror("inet_pton");
exit(0);
}
#endif
if( bind(fd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
perror("bind");
exit(0);
}
//3.listen()函数
listen(fd,5);
//4.1 accept
int newfd = -1;
struct sockaddr_in cin;
socklen_t socklen = sizeof(cin);
//5.实现IO多路复用
int maxfd = -1;
int ret,readwrite;
char buf[BUFSIZ];
char buf02[BUFSIZ + 10];
fd_set rset;
fd_set rset_temp;//副表
struct timeval tout;
tout.tv_sec = 5;
tout.tv_usec = 0;
maxfd = maxfd > fd? maxfd:fd;
FD_SET(fd,&rset);//加入到集合
printf("fd=%d\n",fd);//3
while(1){
rset_temp = rset;
ret = select(maxfd+1,&rset_temp,NULL,NULL,&tout);//返回连接的个数
if(ret < 0){
perror("select\n");
}
//在循环里面判断是连接还是数据
int i;
for(i=3;inewfd?maxfd:newfd;//每次有新的文件描述符加入就更新最大文件描述符
char ipv4_addr[16];
if(!inet_ntop(AF_INET,&cin.sin_addr,ipv4_addr,socklen)){
perror("inet_ntop");
exit(0);
}
printf("client(%s,%d) is connect\n",ipv4_addr,ntohs(cin.sin_port));
}else{//说明有新的数据读取
bzero(buf,sizeof(buf));
bzero(buf02,sizeof(buf02));
do{
readwrite = read(i,buf,BUFSIZ-1);
}while(readwrite < 0 && EINTR == errno);
if(readwrite < 0){
perror("read");
exit(0);
}
if(!readwrite){
FD_CLR(i,&rset);//客户端断开连接,从集合里面清除i
close(i);
continue;
}
printf("result=%s\n",buf);
//返回消息给发送端
strncpy(buf02,BUFADD,strlen(BUFADD));
strcat(buf02,buf);
do{
readwrite = write(newfd,buf02,strlen(buf02));
}while(readwrite < 0 && EINTR == errno);
if(!strncasecmp(buf,QUIT,strlen(QUIT))){
FD_CLR(i,&rset);//客户端断开连接,从集合里面清除i
close(i);
printf("通话结束fd = %d\n",i);
}
/*over...*/
}
//ret--;
}
}
}
close(fd);
return 0;
}
2.client端
/*./client serv_ip serv_port */
#include "net.h"
void usage (char *s)
{
printf ("\n%s serv_ip serv_port", s);
printf ("\n\t serv_ip: server ip address");
printf ("\n\t serv_port: server port(>5000)\n\n");
}
int main (int argc, char **argv)
{
int fd = -1;
int port = -1;
struct sockaddr_in sin;
if (argc != 3) {
usage (argv[0]);
exit (1);
}
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
port = atoi (argv[2]);
if (port < 5000) {
usage (argv[0]);
exit (1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (port); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
#else
if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("connect");
exit (1);
}
printf ("Client staring...OK!\n");
int ret = -1;
fd_set rset;
int maxfd = -1;
struct timeval tout;
char buf[BUFSIZ];
while (1) {
FD_ZERO (&rset);
FD_SET (0, &rset);
FD_SET (fd, &rset);
maxfd = fd;
tout.tv_sec = 5;
tout.tv_usec = 0;
select (maxfd + 1, &rset, NULL, NULL, &tout);
if (FD_ISSET (0, &rset)) { //标准键盘上有输入
//读取键盘输入，发送到网络套接字fd
bzero (buf, BUFSIZ);
do {
ret = read (0, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read");
continue;
}
if (!ret)
continue;
if (write (fd, buf, strlen (buf)) < 0) {
perror ("write() to socket");
continue;
}
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client is exiting!\n");
break;
}
}
if (FD_ISSET (fd, &rset)) { //服务器给发送过来了数据
//读取套接字数据，处理
bzero (buf, BUFSIZ);
do {
ret = read (fd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read from socket");
continue;
}
if (!ret)
break; /* 服务器关闭 */
//There is a BUG,FIXME!!
printf ("server said: %s\n", buf);
if ((strlen(buf) > strlen(SERV_RESP_STR))
&& !strncasecmp (buf+strlen(SERV_RESP_STR), QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Sender Client is exiting!\n");
break;
}
}
}
/*4.关闭套接字 */
close (fd);
}
3.net.h端
#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__
#include
#include
#include
#include
#include
#include
#include /* See NOTES */
#include
#include
#include /* superset of previous */
#include
#include
//#include
#include
#define SERV_PORT 5002
#define SERV_IP_ADDR "192.168.7.246"
#define BACKLOG 5
#define QUIT_STR "quit"
#define SERV_RESP_STR "SERVER:"
#endif 1.4信号驱动I/O
2.epoll的使用
深入理解epoll和select/poll的区别，重点。详情参考文末的参考文献。
1.server端 服务端修改为epoll的结构
#include "net.h"
#include
int main(int argc, const char *argv[])
{
int fd;
struct sockaddr_in sin;
//1.创建socket fd
fd = socket(AF_INET,SOCK_STREAM,0);
if(fd < 0){
perror("socket");
exit(0);
}
/*优化4： 允许绑定地址快速重用 */
int b_reuse = 10;
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
//2.bind函数
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT);
//优化1
#if 0
sin.sin_addr.s_addr = htonl(INADDY_ANY);
#else
if(inet_pton(AF_INET,SERV_IP_ADDR,&sin.sin_addr)< 0){
perror("inet_pton");
exit(0);
}
#endif
if( bind(fd,(struct sockaddr*)&sin,sizeof(sin)) < 0){
perror("bind");
exit(0);
}
//3.listen()函数
listen(fd,5);
//4.1 accept需要的参数定义
int newfd = -1;
struct sockaddr_in cin;
socklen_t socklen = sizeof(cin);
int ret,readwrite;
char buf[BUFSIZ];
char buf02[BUFSIZ + 10];
//5.实现IO多路复用
int maxfd = -1;
int epfd;
struct epoll_event event;
struct epoll_event events[20];
memset(events,0,20*sizeof(struct epoll_event));
event.events = EPOLLIN;//对应的文件描述符可读
event.data.fd = fd;
epfd = epoll_create(1);//创建epoll
epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&event);//fd是需要监听的fd
while(1){
ret = epoll_wait(epfd,events,20,-1);//等待epfd上的io事件，最多返回20个事件。
if(ret < 0){
perror("select\n");
}
//在循环里面判断是连接还是数据
int i;
for(i=0;i< ret ;i++){
if(events[i].data.fd == fd){//有任务事件的文件描述符
//阻塞等待客户端连接
newfd = accept(events[i].data.fd,(struct sockaddr*)&cin,&socklen);
if(newfd < 0){
perror("accept");
exit(0);
}
event.events = EPOLLIN;//对应的文件描述符可读
event.data.fd = newfd;
epoll_ctl(epfd,EPOLL_CTL_ADD,newfd,&event);
//打印客户端信息
char ipv4_addr[16];
if(!inet_ntop(AF_INET,&cin.sin_addr,ipv4_addr,socklen)){
perror("inet_ntop");
exit(0);
}
printf("client(%s,%d) is connect\n",ipv4_addr,ntohs(cin.sin_port));
}else{//说明有新的数据读取
bzero(buf,sizeof(buf));
bzero(buf02,sizeof(buf02));
do{
readwrite = read(events[i].data.fd,buf,BUFSIZ-1);
}while(readwrite < 0 && EINTR == errno);
if(readwrite < 0){
perror("read");
exit(0);
}
if(!readwrite){
//客户端断开连接,从集合里面清除i
event.events = EPOLLIN;//对应的文件描述符可读
event.data.fd = events[i].data.fd;
epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,&event);
close(events[i].data.fd);
continue;
}
printf("result=%s\n",buf);
//返回消息给发送端
strncpy(buf02,BUFADD,strlen(BUFADD));
strcat(buf02,buf);
do{
readwrite = write(newfd,buf02,strlen(buf02));
}while(readwrite < 0 && EINTR == errno);
if(!strncasecmp(buf,QUIT,strlen(QUIT))){
event.events = EPOLLIN;//对应的文件描述符可读
event.data.fd = events[i].data.fd;
epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,&event);
close(events[i].data.fd);
printf("通话结束fd = %d\n",events[i].data.fd);
}
/*over...*/
}
//ret--;
}
}
close(fd);
return 0;
}
总结
多路复用参考文献:
参考直播： http://www.makeru.com.cn/live/5413_1937.html（参考代码见课程资料）
参考博客： https://segmentfault.com/a/1190000003063859
参考播客： http://blog.csdn.net/davidsguo008/article/details/73556811