Linux网络编程——IO多路复用
文章目录
- 1，I/O模型
- 2，阻塞I/O 模式
-
- 2.1，读阻塞（以read函数为例）
- 2.2，写阻塞
- 3，非阻塞I/O模式
-
- 3.1，非阻塞I/O模式的实现（fcntl()函数、ioctl() 函数）
-
- 3.1.1，fcntl( )函数
- 3.1.2，ioctl() 函数
- 4，多路复用I/O
-
- 4.0 文件描述符表
-
- 4.0.1，fd_set
- 4.1，实现多路复用函数 select()/poll()
-
- 4.1.1， select()
- 4.1.2，pselect()/poll()
- 4.1.3，epoll接口
- 5，TCP多路复用
- 6，IO复用select()示例
-
- 6.1 select()---net.h
- 6.2 select()---client.c
- 6.3 select()---sever.c
- 6.4 select()---linklist.h
- 6.5 select()---linklist.c
1，I/O模型
在UNIX/Linux下主要有4种I/O 模型：
| I/O模型 | 含义 |
|---|---|
| 阻塞I/O | 最常用 |
| 非阻塞I/O | 可防止进程阻塞在I/O操作上，需要轮询 |
| I/O 多路复用 | 允许同时对多个I/O进行控制 |
| 信号驱动I/O | 一种异步通信模型（当IO有事件的时 候，在应用程序中会收到一个信号SIGIO，可以对信号安装一个处理句柄，就可以对信号实现异步的处理）用signal函数 |
2，阻塞I/O 模式
- 阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。
- 缺省情况下，socket套接字建立后所处于的模式就是阻塞I/O 模式。
- 前面学习的很多读写函数在调用过程中会发生阻塞。
- 读操作中的read、recv、recvfrom
- 写操作中的write、send
- 其他操作：accept、connect
2.1，读阻塞（以read函数为例）
- 进程调用read函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read将发生阻塞。
- 它会一直阻塞下去，等待套接字的接收缓冲区中有数据可读。
- 经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过read访问这些数据。
- 如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去。
2.2，写阻塞
- 在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
- 这时，写操作不进行任何拷贝工作，将发生阻塞。
- 一但发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。
- UDP不用等待，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞，例如sendto（）。
3，非阻塞I/O模式
- 当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”
- 当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。
- 应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
- 这种模式很少使用。
3.1，非阻塞I/O模式的实现（fcntl()函数、ioctl() 函数）
- 当你一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞IO模式。
- 可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
3.1.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);
3.1.2，ioctl() 函数
使用实例：
int b_on =1;
ioctl(sock_fd, FIONBIO, &b_on);
4，多路复用I/O
-
基本常识：linux中每个进程最多可以打开1024个文件，最多有1024个文件描述符，文件描述符特点：1.非负整数，2.从最小可用 数字来分配，3.每个进程启动时默认打开1、2、3三个文件描述符.【系统设定的】
-
应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
-
若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
-
若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；
-
多路复用不止针对套接字fd，也针对普通的文件描述符fd
-
比较好的方法是使用I/O多路复用。其基本思想是：【详情见5，TCP多路复用】
- 先构造一张有关描述符的表（fd_set），
- 然后调用一个函数（select()/poll()）去监控fd_set中的哪些文件描述符发生阻塞。
- 当监控到某个文件描述符中的一个或多个已准备好进行I/O时函数才退出select（）阻塞。
- 依次判断哪个文件描述符有数据
- 依次处理有数据的文件描述符的上的数据
4.0 文件描述符表
4.0.1，fd_set
void FD_zero(fd_set * fdset);//对集合清零
void FD_set(int fd,fd_set * fdset);//把fd加入到集合中
void FD_CLR(int fd,fd_set * fdset);//从集合汇总清除fd
void FD_ISSET(int fd,fd_set * fdset);//片段fd是否存在fd_set中
4.1，实现多路复用函数 select()/poll()
4.1.1， select()
#include 参数：
- nfds：所有监控的文件描述符中最大的那一个加1（maxfd+1）
- read_fds ：所有要读的文件文件描述符的集合
- write_fds：所有要的写文件文件描述符的集合（一般填NULL）
- except_fds：其他要向我们通知的文件描述符（异常集合，如：带外数据。一般填NULL）
- timeout：超时设置.
- Null：一直阻塞，直到有文件描述符就绪或出错
- 时间值为0：仅仅检测文件描述符集的状态，然后立即返回
- 时间值不为0：在指定时间内，如果没有事件发生，则超时返回。
struct timeval {
long tv_sec; /* seconds 秒*/
long tv_usec; /* microseconds 微妙*/
};
- 在我们调用select时进程会一直阻塞直到以下的一种情况发生.
- 有文件可以读.
- 有文件可以写.
- 超时所设置的时间到.
- 为了设置文件描述符我们要使用几个宏：
| 宏 | 形式 | 含义 |
|---|---|---|
| FD_SET | void FD_SET(int fd,fd_set *fdset) | 将fd加入到fdset |
| FD_CLR | void FD_CLR(int fd,fd_set *fdset) | 将fd从fdset里面清除 |
| FD_ZERO | void FD_ZERO(fd_set *fdset) | 从fdset中清除所有的文件描述符 |
| FD_ISSET | int FD_ISSET(int fd,fd_set *fdset) | 判断fd是否在fdset集合中 |
4.1.2，pselect()/poll()
int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);
- 注意参数类似struct timespec 和sigset_t
- select()增强
struct timespec {
long tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
- 类似select(),稍节省空间
- 第二个参数nfds：要监视的描述符的数目。
- 最后一个参数timeout：是一个用毫秒表示的时间，是指定poll在返回前没有接收事件时应该等待的时间。如果 它的值为-1，poll就永远都不会超时。如果整数值为32个比特，那么最大的超时周期大约是30分钟。
- 第一个参数是结构体
struct pollfd {
int fd; /* file descriptor */
short events; /* requested events */
short revents; /* returned events */
};
| 常量(events/revents) | 说明 |
|---|---|
| POLLIN | 普通或优先级带数据可读，有数据可读 |
| POLLRDNORM | 普通数据可读，有普通数据可读 |
| POLLRDBAND | 优先级带数据可读，有优先数据可读 |
| POLLPRI | 高优先级数据可读， 有紧迫数据可读 |
| POLLOUT | 普通数据可写， 写数据不会导致阻塞 |
| POLLWRNORM | 普通数据可写， 写普通数据不会导致阻塞 |
| POLLWRBAND | 优先级带数据可写，写优先数据不会导致阻塞 |
| POLLMSGSIGPOLL | 消息可用 |
| POLLER | 发生错误 |
| POLLHUP | 发生挂起 |
| POLLNVAL | 描述字不是一个打开的文件 |
4.1.3，epoll接口
epoll的接口非常简单，一共就三个函数：
int epoll_create(int size);
- 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
- epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：
| 宏（动作） | 含义 |
|---|---|
| EPOLL_CTL_ADD | 注册新的fd到epfd中 |
| EPOLL_CTL_MOD | 修改已经注册的fd的监听事件 |
| EPOLL_CTL_DEL | 从epfd中删除一个fd |
第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下
typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
| 宏（enents） | 含义 |
|---|---|
| EPOLLIN | 表示对应的文件描述符可以读（包括对端SOCKET正常关闭） |
| EPOLLOUT | 表示对应的文件描述符可以写 |
| EPOLLPRI | 表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来） |
| EPOLLERR | 表示对应的文件描述符发生错误 |
| EPOLLHUP | 表示对应的文件描述符被挂断 |
| EPOLLET | 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的 |
| EPOLLONESHOT | 只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里 |
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
epoll_wait的功能与select()类似，它等待_epfd_所代表的epoll实例中监听的事件发生。
参数：
- events指针返回已经准备好的事件，最多有maxevents个，
- 参数maxevent必须大于零。
- timeout参数指定epoll_wait函数阻塞的毫秒数的最小值（精度和系统时钟有关，内核调度也会对此造成一些影响），设置timeout为-1则epoll_wait()会一直阻塞，设置为0则会立即返回。
返回值
- 如果函数调用成功，epoll_wait()函数返回已经准备好进行所要求的I/O操作的文件描述符的数
量，如果在_timeout_时间内没有描述符准备好则返回0。 - 出错时，epoll_wait()返回-1并且把errno设置为对应的值
5，TCP多路复用
TCP多路复用IO
- select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化：
前：表示关心的文件描述符集合
后：有数据的集合（如不是在超时还回情况下）
1.1. 因为kernel使fd_set集合发生了变化，将没有数据的文件描述符进行移除，只剩下有数据的 - 若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数 4. 若是已建立连接的套接字上有数据，则去读数据
int main(void)
{
fd_set rset;
int maxfd = -1;
struct timeval tout;
fd = socket(...);
bind(fd,...);
listen(fd,...);
while(1)
{
maxfd = fd;
FD_ZERO(&rset);
FD_SET(fd,&rset);
/*依次把已经建立好连接的fd加入到集合中，记录下来最大的文件描述符maxfd*/
#if 0
select(maxfd+1,&rset,NULL,NULL,NULL);
#else
struct timeval tout;
tout.tv_sec = 5;
tout.tv_usec = 0;
select(maxfd+1,&rset,NULL,NULL,&tout);
#endif
int newfd;
if(FD_ISSET(fd,&rset))//依次判断，有多少文件描述符需要判断就写几个if判断语句
{
newfd = accept(fd,...);//若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数
}
/* 若是已建立连接的套接字上有数据，则去读数据 */
/* ... */
}
}
6，IO复用select()示例
6.1 select()—net.h
#ifndef __NET_H__
#define __NET_H__
#include 6.2 select()—client.c
/* ./client serv_ip serv_port */
#include "net.h"
void usage(char *s)
{
printf("Usage: %s \n" ,s);
printf("\tserv_ip: server ip address\n");
printf("\tserv_port: server port(>5000)\n ");
}
int main(int argc, const char *argv[])
{
int fd;
short port;
struct sockaddr_in sin;
if(argc != 3)
{
usage((char *)argv[0]);
exit(1);
}
if((port = atoi(argv[2])) < 5000)
{
usage((char *)argv[0]);
exit(1);
}
/* 1 创建socket fd */
if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
{
perror("socket");
exit(-1);
}
/* 2 连接服务器 */
/* 2.1 填充struct sockaddr_in结构体变量*/
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);//转为网络字节序端口号
if(inet_pton(AF_INET,argv[1],(void *)&sin.sin_addr.s_addr) < 0)
{
perror("inet_pton");
goto _error1;
}
/* 2.2 连接服务器*/
if(connect(fd,(struct sockaddr *)&sin,sizeof(sin)) < 0)
{
perror("connect");
goto _error1;
}
printf("client staring ... OK!\n");
fd_set rset;
int maxfd = -1;
struct timeval tout;
char buf[BUFSIZ];
int ret = -1;
while(1)
{
FD_ZERO(&rset);
//将文件描述符添加到rset数组中
FD_SET(0,&rset);//0sh标准输入的文件描述符
FD_SET(fd,&rset);//fd是socket的文件描述符
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 == 0)//没读到数据
{
continue;
}
if(write(fd,buf,strlen(buf)) < 0)
{
perror("write() to socket");
continue ;
}
if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0)//退出在发送之后
{
printf("client is existing!\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 == 0)//从套接字中读到的数据个数小于0，说明服务器关闭
{
break ;
}
printf("server said: %s",buf);
if((strlen(buf) > strlen(SERV_RESP_STR)) && strncasecmp(buf+strlen(SERV_RESP_STR),QUIT_STR,strlen(QUIT_STR)) == 0)
{
printf("sender client is existing!\n");
break;
}
}
}
_error1:
close(fd);
return 0;
}
6.3 select()—sever.c
#include "net.h"
#include "linklist.h"
#include 6.4 select()—linklist.h
#ifndef __SINGLE_LINKLIST_H__
#define __SINGLE_LINKLIST_H__
#include 6.5 select()—linklist.c
#include "linklist.h"
linklist create_linklist(void)
{
linklist L;
if((L=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!\n");
return NULL;
}
L->data.fd = 0;
bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));
L->data.port = 0;
L->next = NULL;
return L;
}
linklist create_n_linklist(void)
{
linklist L,H,r;
datatype x;
if((L=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!\n");
return NULL;
}
L->data.fd = 0;
bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));
L->data.port = 0;
L->next = NULL;
r = L;
while(1)
{
printf("Please input a NUM_NL80211_WOWLAN_TRIGber(-1 exit :");
while(scanf("%d",&x.fd) != 1)
{
printf("Please INPUT_PROP_CNTut a number(-1 exit :");
getchar();
}
if(x.fd == -1)break;
if((H=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc nexto memmory!\n");
return L;
}
H->data = x;
H->next = NULL;
r->next = H;
r=H;
}
return L;
}
int delete_pos_linklist(linklist L,int pos)
{
linklist r,p;
int i=-1;
if(pos < 0 ||pos >=get_length_linklist(L))
{
printf("input pos is invalid!\n");
return -1;
}
r = L;
while(i < pos-1)
{
i++;
r = r->next;
}
if(r == NULL || r->next==NULL)
{
printf("argc is iavalid!\n");
return -1;
}
else
{
p = r->next;
r->next = p->next;
p->next = NULL;
free(p);
return 0;
}
}
int delete_locate_linklist(linklist L,datatype x)
{
linklist r,p;
if(L->next == NULL)
{
printf("list is NULL!\n");
return -1;
}
r = L;
while(r->next->data.fd != x.fd)
{
if(r->next == NULL)
{
printf("value is not in list!\n");
return -1;
}
r = r->next;
}
p = r->next;
r->next = p->next;
p->next = NULL;
free(p);
return 0;
}
void clear_linklist(linklist L)
{
while(get_length_linklist(L))
{
delete_pos_linklist(L,get_length_linklist(L)-1);
}
free(L);
L->next = NULL;
L = NULL;
}
int get_length_linklist(linklist L)
{
int i=0;
linklist r;
r = L;
while(r->next)
{
r = r->next;
i++;
}
return i++;
}
linklist get_list_pos_linklist(linklist L,int pos)
{
int i=0;
linklist r;
if(L->next == NULL)
{
printf("list is NULL!\n");
return NULL;
}
if(pos<0 || pos>=get_length_linklist(L))
{
printf("input is invalid!\n");
return NULL;
}
r = L->next;
while(i<pos)
{
r = r->next;
i++;
}
return r;
}
linklist get_list_locate_linklist(linklist L,datatype x)
{
linklist r;
if(L->next == NULL)
{
printf("list is NULL!\n");
return NULL;
}
r = L->next;
while(r->data.fd != x.fd)
{
if(r->next == NULL)
{
printf("value is not in list!\n");
return NULL;
}
r = r->next;
}
return r;
}
int insert_head_linklist(linklist L,datatype x)
{
linklist H;
if((H=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory\n");
return -1;
}
H->data = x;
H->next = L->next;
L->next = H;
return 0;
}
int insert_n_head_linklist(linklist L)
{
datatype x;
while(1)
{
printf("Please input a number(-1 exit:");
while(scanf("%d",&x.fd) != 1)
{
printf("Please input a number:(-1 exit");
getchar();
}
if(x.fd == -1)break;
insert_head_linklist(L,x);
}
return 0;
}
int insert_end_linklist(linklist L,datatype x)
{
linklist r,H;
if((H = (linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!");
return -1;
}
r = L;
while(r->next)
{
r = r->next;
}
H->next = NULL;
H->data = x;
r->next = H;
return 0;
}
int insert_n_end_linklist(linklist L)
{
datatype x;
while(1)
{
printf("Please input a number(-1 exit:");
while(scanf("%d",&x.fd) != 1)
{
printf("Please input a number:(-1 exit");
getchar();
}
if(x.fd == -1)break;
insert_end_linklist(L,x);
}
return 0;
}
int insert_pos_linklist(linklist L,datatype x,int pos)
{
linklist K,r;
if(pos == 0)
{
r = L;
}
else
{
r = get_list_pos_linklist(L,pos-1);
}
if(r == NULL)
{
printf("argc is invalidateid!\n");
return -1;
}
else
{
if((K = (linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!");
return -1;
}
K->data = x;
K->next = r->next;
r->next = K;
}
return 0;
}
int insert_order_linklist(linklist L,datatype x)
{
linklist r,H;
if((H = (linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc nexto memmory!\n");
return -1;
}
H->data = x;
r = L;
while(r->next && r->next->data.fd < x.fd)
{
r = r->next;
}
H->next = r->next;
r->next = H;
return 0;
}
void reverse_linklist(linklist L)
{
linklist r,p;
if(L->next == NULL)
{
printf("list is NULL!\n");
return ;
}
r = L->next;
L->next = NULL;
while(r)
{
p = r;
r = r->next;
p->next = L->next;
L->next = p;
}
return ;
}
void sort_linklist(linklist L)
{
linklist r,p,q;
if(L == NULL)
{
printf("list is NULL!\n");
return ;
}
r = L->next;
L->next = NULL;
while(r)
{
p = r;
r = r->next;
q = L;
while(q->next && q->next->data.fd < p->data.fd)
{
q = q->next;
}
p->next = q->next;
q->next = p;
}
}
void show_linklist(linklist L)
{
printf("list is:\n");
if(L->next == NULL)
{
printf("\tlist is NULL!list\n");
return ;
}
while(L->next)
{
printf("\t%d %s %d\t",L->next->data.fd,L->next->data.ipv4_addr,L->next->data.port);
L = L->next;
puts("");
}
//puts("");
return ;
}