一. select
前面提到Linux下的五种IO模型中有一个是IO复用模型,这种IO模型是可以调用一个特殊的函数同时监听多个IO事件,当多个IO事件中有至少一个就绪的时候,被调用的函数就会返回通知用户进程来处理已经ready事件的数据,这样通过同时等待IO事件来代替单一等待一个IO窗口数据的方式,可以大大提高系统的等待数据的效率;而接下来,就要讨论在Linux系统中提供的一个用来进行IO多路等待的函数——select;
二. select函数的用法
首先在使用select之前,要分清在IO事件中,往往关心的不是数据的读取就是数据的发送,也就是数据的读和写,当然也有同时关心读写的,没有任何一个IO事件既不关系读也不关心写的,因此,在对于使用select对多个IO事件进行监听检测的时候,就要对这些事件进行读写的分类,以便日后在select返回时通过检测能够得知当前事件是读发生了还是写发生了;
函数参数中,
nfds表示当前最大文件描述符值+1;
readfds表示当前的事件中有多少是关心数据的读取的;
writefds表示当前的事件中有多少是关心数据的写入的;
excptfds表示当前事件中关心异常发生的事件集,也是数据的写入;
其中,fd_set是一个文件符集的数据类型;
对于fd_set文件描述符集的设置,系统提供了四个函数来进行操作:
FD_CLR是对文件描述符集中的所有文件描述符进行清除;
FD_ISSET是判断某个文件描述符是否已经被设置进某个文件描述符集中;
FD_SET是将某个文件描述符设置进某个文件描述符集中;
FD_ZERO是对某个文件描述符集进行初始化;
timeout是时间的设定,表示当超过设定的时间仍然没有事件就绪时就超时返回不再等待;
timeout的结构体类型如下:
tv_sec是秒的设置;
tv_usec是微秒的设置;
对于select函数的返回值:
当返回值为-1的时候,表示函数出错并会置相应的错误码;
当返回值为0的时候,表示超时返回;
当返回值大于0的时候,表示至少已经有一个事件已经就绪可以处理其数据了;
三. 栗子时间
前面有一篇本人写的博客是基于TCP协议的socket编程,其中一个服务器为了能处理多个连接请求将listen监听和accept处理连接请求分开,每当listen到一个连接请求的时候就fork出一个子进程让子进程去处理,或者使用多线程,这样就不耽误对网络中连接请求的监听了;
但是同样是单进程,可以使用select的IO复用模型来解决对多个连接的数据处理,程序设计如下:
server服务器端:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define _BACKLOG_ 5//设置监听队列里面允许等待的最大值
int fds[20];//用于集存需要进行处理的IO事件
void usage(const char *argv)//进行命令行参数的差错判断
{
printf("%s [ip] [port]\n", argv);
exit(0);
}
int creat_listen_sock(int ip, int port)//创建listen socket
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
perror("socket");
exit(1);
}
struct sockaddr_in server;//设置本地server端的网络地址信息
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = ip;
if(bind(sock, (struct sockaddr*)&server, sizeof(server)) < 0)//绑定端口号和网络地址信息
{
perror("bind");
exit(3);
}
if(listen(sock, _BACKLOG_) < 0)//进行监听
{
perror("listen");
exit(2);
}
return sock;
}
int main(int argc, char *argv[])
{
if(argc != 3)
usage(argv[0]);
int port = atoi(argv[2]);
int ip = inet_addr(argv[1]);
int listen_sock = creat_listen_sock(ip, port);//获取监听端口号
struct sockaddr_in client;//创建对端网络地址信息结构体用于保存对端信息
socklen_t client_len = sizeof(client);
size_t fds_num = sizeof(fds)/sizeof(fds[0]);
size_t i = 0;
for(; i < fds_num; ++i)//将存放文件描述符的数组进行初始化
fds[i] = -1;
fds[0] = listen_sock;//首先将listen socket添加进去
fd_set read_fd;//创建读事件文件描述符集
fd_set write_fd;//创建写事件文件描述符集
int max_fd = fds[0];//首先将最大的文件描述符集设定为listen socket
while(1)
{
FD_ZERO(&read_fd);//将两个文件描述符集进行初始化
FD_ZERO(&write_fd);
struct timeval timeout = {10, 0};//设定超时时间
size_t i = 0;
for(; i < fds_num; ++i)//每次循环都要将数组中的文件描述符进行重新添加设置
{
if(fds[i] > 0)
{
FD_SET(fds[i], &read_fd);
if(fds[i] > max_fd)
max_fd = fds[i];
}
}
switch(select(max_fd+1, &read_fd, &write_fd, NULL, &timeout))//进行select等待
{
case -1://出错
perror("select");
break;
case 0://超时
printf("time out...\n");
break;
default://至少有一个IO事件已经就绪
{
size_t i = 0;
for(; i < fds_num; ++i)
{
//当为listen socket事件就绪的时候,就表明有新的连接请求
if(FD_ISSET(fds[i], &read_fd) && (fds[i] == listen_sock))
{
int accept_sock = accept(listen_sock, (struct sockaddr*)&client, &client_len);
if(accept_sock < 0)
{
perror("accept");
continue;
}
char *client_ip = inet_ntoa(client.sin_addr);
int client_port = ntohs(client.sin_port);
printf("connect with a client... [ip]:%s [port]:%d\n", client_ip, client_port);
size_t i = 0;
for(; i < fds_num; ++i)//将新的连接请求的文件描述符添加进数组保存
{
if(fds[i] == -1)
{
fds[i] = accept_sock;
break;
}
}
if(i == fds_num)
close(accept_sock);
}
//除了listen socket就是别的普通进行数据传输的文件描述符
else if(FD_ISSET(fds[i], &read_fd) && (fds[i] > 0))
{
char buf[1024];
ssize_t size = read(fds[i], buf, sizeof(buf)-1);
if(size < 0)
perror("read");
else if(size == 0)
{//当client端关闭就关闭相应的文件描述符
printf("client closed...\n");
close(fds[i]);
fds[i] = -1;
}
else
{
buf[size] = '\0';
printf("client# %s\n", buf);
}
}
else
{}
}
}
break;
}
}
return 0;
}
因为客户端的程序和前面的TCP的程序一样,这里就不再多写;
上面的程序可以分为如下步骤:
创建监听套接字并绑定本地网络地址信息进行监听;
创建一个全局的数组用于存放已有事件的文件描述符,便于重新进行整理;
创建读、写事件集,这里忽略异常事件集;
循环等待各个事件的就绪,每次都重新初始化事件集和重新添加设置,因为select会将没有就绪的事件清为0;
select完成进行返回值的一个判断:如果是-1,则出错返回;如果是0,则超时返回;如果是大于零的值,则表明至少有一个事件就绪,转到第6步;
将数组中的事件拿出一一进行判断:如果是listen socket就绪表明有新的连接请求,新创建一个文件描述符用于处理数据的传输,并将其添置进数组中;如果是别的文件描述符就绪表明有数据传输过来需要读取,转第7步;
读取数据时,如果判断client端关闭就将数组中相应位置还原回无效值并且关闭相应的socket文件描述符,读取成功输出数据,继续循环;
运行程序:
可以注意到上面的程序中sever端只将所有的连接请求都作为读事件添加进去了,而并没有关心写事件,事实上socket支持全双工的通信,因此,将上面的程序改为server端读取数据的同时将数据再写回给client端,以此来告知client端server端已经成功收到了数据,程序改进如下:
在循环每一次重新整理数组中的文件描述符集的时候将不是listen socket的文件描述符集同时添加进读事件集和写事件集:
FD_ZERO(&read_fd);
FD_ZERO(&write_fd);
FD_SET(listen_sock, &read_fd);//先将listen socket添加进读事件集
struct timeval timeout = {10, 0};
size_t i = 1;//循环跳过listen socket从1开始
for(; i < fds_num; ++i)
{
if(fds[i] > 0)
{
FD_SET(fds[i], &read_fd);//同时添加进读事件集和写事件集
FD_SET(fds[i], &write_fd);
if(fds[i] > max_fd)
max_fd = fds[i];
}
}
而当数据就绪进行读取完毕之后,再将同一个缓冲区中的数据写回client端,这里因为读写事件中使用的是同一个文件描述符,因此,当一个socket的读事件准备就绪的时候,说明写事件同样也是就绪的,而且使用同一个缓冲区中相同的数据:
else if(FD_ISSET(fds[i], &read_fd) && (FD_ISSET(fds[i], &write_fd)) && (fds[i] > 0))
{
char buf[1024];
ssize_t size = read(fds[i], buf, sizeof(buf)-1);
if(size < 0)
perror("read");
else if(size == 0)
{
printf("client closed...\n");
close(fds[i]);
fds[i] = -1;
break;
}
else
{
buf[size] = '\0';
printf("client# %s\n", buf);
}
if(FD_ISSET(fds[i], &write_fd))
{
size = write(fds[i], buf, strlen(buf));
if(size < 0)
perror("write");
}
else
printf("can not write back...\n");
}
因此,在client端也需要进行读取;
运行程序:
总结如上,虽然select实现IO复用在等待数据的效率看来要比单一的等待高,但是不难发现当需要等待多个事件的时候,是需要不断地进行复制和循环判断的,这也同样增加了时间复杂度增加了系统的开销,而且,作为一个数据类型的fd_set是由上限的,我的当前机器sizeof(fd_set)值为128,而一个字节能添加8个文件描述符,也就是总共只能添加128*8=1024个文件描述符,这个数目还是有些小的,无疑也是一个缺点。
《完》
转载于:https://blog.51cto.com/2627lounuo/1783654