【Linux】多路复用之—select

一：多路复用之——select

int select(int nfds，fd_set *readfds，fd_set *writefds，fd_set *exceptfds，struct timeval* timeout)

1、参数： （1）nfds：需要监视的文件描述符数目；

（2）readfds、writefds、ecceptfds：对应于需要检测的可读文件描述符集合、可写文件描述符集合、异常文件描述符集合；

（3）timeout：NULL：没有timeout，一直阻塞，直到某个文件描述符发生事件

0：仅检测文件描述符的状态，然后立即返回

特定值：等待timeout时间，如果事件没有发生，超时返回

2、宏：提供处理这三种描述符词组的方式

（1）：FD_CLR(int fd，fd_set* set)清除文件描述符集中相关fd的位

（2）：FD_ISSET(int fd，fd_set* set)测试文件描述符集中与fd相关的事件是否发生

（3）：FD_SET(int fd,，fd_set* set)设置文件描述符集中相关fd的位

（4）：FD_ZERO(int fd，fd_set* set)清除文件描述符集中的全部位

3、timeout：

struct timeout{

long tv_sec 秒

long tv_usec 微妙

}

4、返回值：

（1）成功：返回文件描述符集中状态改变的文件描述符个数

（2）0：超过timeout时间

（3）-1：失败

5、理解select模型：

取fd_set长度为1字节，fd_set中的每一bit位对应一个文件描述符fd，则1字节长的fd_set最多可以对应8个fd

（1）执行fd_set set，DF_ZERO(&set)，则set用位表示为0000 0000

（2）若fd=5，执行fd_set(fd，&set)，后set变为0001 0000

（3）若再加入fd=1，fd=2，则set变为0001 0011

（4）执行select(6，&set，0，0，0)阻塞等待

（5）若fd=1,fd=2都发生，则select返回，set变为0000 0011 注意：没有事件发生的fd=5被清空

6、select模型的特点：

（1）可监控的文件描述符个数取决于sizeof(fd_set)的值；

（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判断是否有事件发生）。

7、select模型的缺点：

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，当fd很多时，开销会很大；

（2）在每次调用select时，都要遍历fd，开销大；

（3）select支持的文件描述符数目太少，默认是1024，不能处理海量数据。

my_select.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<sys/select.h>
#define _PORT_ 8080
#define _BACK_LOG_ 5
#define _MAX_FD_NUM_ 32
int array_fd[_MAX_FD_NUM_];
int startup()
{
int sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0){
perror("socket");
exit(1);
}
struct sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port=htons(_PORT_);
local.sin_addr.s_addr=htonl(INADDR_ANY);
socklen_t len=sizeof(local);
if(bind(sock,(struct sockaddr*)&local,len)<0){
perror("bind");
exit(2);
}
if(listen(sock,_BACK_LOG_)<0){
perror("listen");
exit(3);
}
return sock;
}
int main()
{
int listen_sock=startup();
struct sockaddr_in client;
socklen_t len=sizeof(client);
fd_set read_set;
int i=0;
int max_fd=listen_sock;
array_fd[0]=listen_sock;
for(i=1;i<_MAX_FD_NUM_;i++){
array_fd[i]=-1;
}
while(1){
FD_ZERO(&read_set);
for(i=0;i<_MAX_FD_NUM_;i++){
if(array_fd[i]>0){
FD_SET(array_fd[i],&read_set);
if(max_fd<array_fd[i]){
max_fd=array_fd[i];
}
}
}
struct timeval time_out={3,0};
switch(select(max_fd+1,&read_set,NULL,NULL,&time_out)){
case 0://timeout
printf("timeout...\n");
break;
case -1://error
perror("select");
break;
default:
{
for(i=0;i<_MAX_FD_NUM_;i++){
if(array_fd[i]<0){
continue;
}else if(array_fd[i]==listen_sock && FD_ISSET(array_fd[i],&read_set)){
int new_sock=accept(array_fd[i],(struct sockaddr*)&client,&len);
if(new_sock<0){
continue;
}
printf("get a new connect...\n");
for(i=0;i<_MAX_FD_NUM_;i++){
if(array_fd[i]==-1){
array_fd[i]=new_sock;
break;
}
}
if(i==_MAX_FD_NUM_){
printf("array_fd is full\n");
close(new_sock);
}
}else{
for(i=1;i<_MAX_FD_NUM_;i++){
if(array_fd[i]>0 && FD_ISSET(array_fd[i],&read_set)){
char buf[1024];
memset(buf,'\0',sizeof(buf)-1);
ssize_t _size=read(array_fd[i],buf,sizeof(buf)-1);
if(_size==0){
printf("client close...\n");
close(array_fd[i]);
array_fd[i]=-1;
}else if(_size<0){
}else{
printf("client: %s\n",buf);
}
}
}
}
}
}
break;
}
}
close(listen_sock);
return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
#define _PORT_ 8080
int main()
{
int read_fd=0;
int write_fd=1;
fd_set read_set;
fd_set write_set;
int max_fd=0;
int sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0){
perror("socket");
exit(1);
}
struct sockaddr_in remote;
remote.sin_family=AF_INET;
remote.sin_port=htons(_PORT_);
remote.sin_addr.s_addr=inet_addr("192.168.0.146");
if(connect(sock,(struct sockaddr*)&remote,sizeof(remote))<0){
perror("connect");
exit(2);
}
if(sock>read_fd){
max_fd=sock;
}else{
max_fd=read_fd;
}
while(1){
FD_ZERO(&read_set);
FD_ZERO(&write_set);
FD_SET(read_fd,&read_set);
FD_SET(sock,&write_set);
switch(select(max_fd+1,&read_set,&write_set,NULL,NULL)){
case 0:
printf("timeout...\n");
break;
case -1:
perror("select");
break;
default:
{
if(FD_ISSET(read_fd,&read_set)){
char buf[1024];
memset(buf,'\0',sizeof(buf));
ssize_t _size=read(read_fd,buf,sizeof(buf)-1);
if(_size>0){
buf[_size]='\0';
printf("echo: %s\n",buf);
}
if(FD_ISSET(sock,&write_set)){
send(sock,buf,strlen(buf),0);
}
}
}
break;
}
}
return 0;
}

Makefile

.PHONY:all
all:my_select client
my_select:my_select.c
gcc -o $@ $^
client:client.c
gcc -o $@ $^
.PHONY:clean
clean:
rm -rf my_select client