select、poll和epoll本质上都是实现IO多路复用的并发模型，主要区别在于应用场景和实现机制的不同。
select
select是将所有的描述符状态保存进fd_set中，然后遍历fd_set的状态变化来进行相应的操作。它的主要缺点有：
- 采用轮询的方式遍历所有描述符的状态，当数量较多时效率低下；
- 单个进程支持最大并发连接的数量有限，通常为1024个；
- 大量的fd_set数据结构需要从用户到内核的不断拷贝，效率低；
- 大量高并发时使用多个进程实现还需要进程上下文切换的开销；
- 如果触发了某个描述符这次没有处理，那么下次仍然会触发。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
#define PORT 8888
#define MAX_LINE 2048
#define LISTENQ 20
int main(int argc , char **argv)
{
int i, maxi, maxfd, listenfd, connfd, sockfd;
int nready , client[FD_SETSIZE];
ssize_t n, ret;
fd_set rset , allset;
char buf[MAX_LINE];
socklen_t clilen;
struct sockaddr_in servaddr , cliaddr;
/*(1) 得到监听描述符*/
listenfd = socket(AF_INET , SOCK_STREAM , 0);
/*(2) 绑定套接字*/
bzero(&servaddr , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
bind(listenfd , (struct sockaddr *)&servaddr , sizeof(servaddr));
/*(3) 监听*/
listen(listenfd , LISTENQ);
/*(4) 设置select*/
maxfd = listenfd;
maxi = -1;
for(i=0 ; i<FD_SETSIZE ; ++i)
{
client[i] = -1;
}//for
FD_ZERO(&allset);
FD_SET(listenfd , &allset);
/*(5) 进入服务器接收请求死循环*/
while(1)
{
rset = allset;
nready = select(maxfd+1 , &rset , NULL , NULL , NULL);
if(FD_ISSET(listenfd , &rset))
{
/*接收客户端的请求*/
clilen = sizeof(cliaddr);
printf("\naccpet connection~\n");
if((connfd = accept(listenfd , (struct sockaddr *)&cliaddr , &clilen)) < 0)
{
perror("accept error.\n");
exit(1);
}//if
printf("accpet a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr) , cliaddr.sin_port);
/*将客户链接套接字描述符添加到数组*/
for(i=0 ; i<FD_SETSIZE ; ++i)
{
if(client[i] < 0)
{
client[i] = connfd;
break;
}//if
}//for
if(FD_SETSIZE == i)
{
perror("too many connection.\n");
exit(1);
}//if
FD_SET(connfd , &allset);
if(connfd > maxfd)
maxfd = connfd;
if(i > maxi)
maxi = i;
if(--nready < 0)
continue;
}//if
for(i=0; i<=maxi ; ++i)
{
if((sockfd = client[i]) < 0)
continue;
if(FD_ISSET(sockfd , &rset))
{
/*处理客户请求*/
printf("\nreading the socket~~~ \n");
bzero(buf , MAX_LINE);
if((n = read(sockfd , buf , MAX_LINE)) <= 0)
{
close(sockfd);
FD_CLR(sockfd , &allset);
client[i] = -1;
}//if
else{
printf("clint[%d] send message: %s\n", i , buf);
if((ret = write(sockfd , buf , n)) != n)
{
printf("error writing to the sockfd!\n");
break;
}//if
}//else
if(--nready <= 0)
break;
}//if
}//for
}//while
}
poll
poll跟select本质思路是一致的，也是需要轮询描述符状态来实现，主要的区别在于poll是使用链表来保存多个描述符的监听，所以就没有了最大连接限制，但仍然效率低下。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <sys/socket.h>
#include <poll.h>
#include <limits.h> /*for OPEN_MAX*/
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
#ifndef OPEN_MAX
#define OPEN_MAX 1024
#endif
#ifndef INFTIM
#define INFTIM -1
#endif
#define PORT 8888
#define MAX_LINE 2048
#define LISTENQ 20
int main(int argc , char **argv)
{
int i, maxi, listenfd, connfd, sockfd;
int nready;
ssize_t n, ret;
struct pollfd client[OPEN_MAX];
char buf[MAX_LINE];
socklen_t clilen;
struct sockaddr_in servaddr , cliaddr;
/*(1) 得到监听描述符*/
listenfd = socket(AF_INET , SOCK_STREAM , 0);
/*(2) 绑定套接字*/
bzero(&servaddr , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
bind(listenfd , (struct sockaddr *)&servaddr , sizeof(servaddr));
/*(3) 监听*/
listen(listenfd , LISTENQ);
/*(4) 设置poll*/
client[0].fd = listenfd;
client[0].events = POLLRDNORM;
for(i=1 ; i<OPEN_MAX ; ++i)
{
client[i].fd = -1;
}//for
maxi = 0;
/*(5) 进入服务器接收请求死循环*/
while(1)
{
nready = poll(client , maxi+1 , INFTIM);
if(client[0].revents & POLLRDNORM)
{
/*接收客户端的请求*/
clilen = sizeof(cliaddr);
printf("\naccpet connection~\n");
if((connfd = accept(listenfd , (struct sockaddr *)&cliaddr , &clilen)) < 0)
{
perror("accept error.\n");
exit(1);
}//if
printf("accpet a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr) , cliaddr.sin_port);
/*将客户链接套接字描述符添加到数组*/
for(i=1 ; i<OPEN_MAX ; ++i)
{
if(client[i].fd < 0)
{
client[i].fd = connfd;
break;
}//if
}//for
if(OPEN_MAX == i)
{
perror("too many connection.\n");
exit(1);
}//if
/*该描述符等待的事件*/
client[i].events = POLLRDNORM;
if(i > maxi)
maxi = i;
if(--nready < 0)
continue;
}//if
for(i=1; i<=maxi ; ++i)
{
if((sockfd = client[i].fd) < 0)
continue;
/*该链接描述符实际发生的事件*/
if(client[i].revents & (POLLRDNORM | POLLERR))
{
/*处理客户请求*/
printf("\nreading the socket~~~ \n");
bzero(buf , MAX_LINE);
if((n = read(sockfd , buf , MAX_LINE)) <= 0)
{
close(sockfd);
client[i].fd = -1;
}//if
else{
printf("clint[%d] send message: %s\n", i , buf);
if((ret = write(sockfd , buf , n)) != n)
{
printf("error writing to the sockfd!\n");
break;
}//if
}//else
if(--nready <= 0)
break;
}//if
}//for
}//while
exit(0);
}
epoll
epoll对于每一个创建的epoll对象都会维护一个红黑树和一个双链表，红黑树存储着所有添加到epoll中需要监控的描述符，而双链表则存放着将要通过epoll_wait返回给用户的满足条件的描述符，而epoll_wait则又采用了回调的方式将触发的描述符返回给用户，除此之外epoll还使用了内存映射的方式将添加的描述符映射到内核空间（内存共享），避免了拷贝的代价。因此epoll的并发高效性远远优于select和poll，但是有一点必须清楚，当连接数不大，并且连接点都处于比较活跃的状态，那么epoll的效率就不如前两者了，毕竟回调通知的方式在大用户量下也会很慢。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
#ifndef CONNECT_SIZE
#define CONNECT_SIZE 256
#endif
#define PORT 7777
#define MAX_LINE 2048
#define LISTENQ 20
void setNonblocking(int sockfd)
{
int opts;
opts=fcntl(sockfd,F_GETFL);
if(opts<0)
{
perror("fcntl(sock,GETFL)");
return;
}//if
opts = opts|O_NONBLOCK;
if(fcntl(sockfd,F_SETFL,opts)<0)
{
perror("fcntl(sock,SETFL,opts)");
return;
}//if
}
int main(int argc , char **argv)
{
int i, listenfd, connfd, sockfd, epfd, nfds;
ssize_t n, ret;
char buf[MAX_LINE];
socklen_t clilen;
struct sockaddr_in servaddr , cliaddr;
/*声明epoll_event结构体变量，ev用于注册事件，数组用于回传要处理的事件*/
struct epoll_event ev, events[20];
/*(1) 得到监听描述符*/
listenfd = socket(AF_INET , SOCK_STREAM , 0);
setNonblocking(listenfd);
/*生成用于处理accept的epoll专用文件描述符*/
epfd = epoll_create(CONNECT_SIZE);
/*设置监听描述符*/
ev.data.fd = listenfd;
/*设置处理事件类型*/
ev.events = EPOLLIN | EPOLLET;
/*注册事件*/
epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
/*(2) 绑定套接字*/
bzero(&servaddr , sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
bind(listenfd , (struct sockaddr *)&servaddr , sizeof(servaddr));
/*(3) 监听*/
listen(listenfd , LISTENQ);
/*(4) 进入服务器接收请求死循环*/
while(1)
{
/*等待事件发生*/
nfds = epoll_wait(epfd , events , CONNECT_SIZE , -1);
if(nfds <= 0)
continue;
printf("nfds = %d\n" , nfds);
/*处理发生的事件*/
for(i=0 ; i<nfds ; ++i)
{
/*检测到用户链接*/
if(events[i].data.fd == listenfd)
{
/*接收客户端的请求*/
clilen = sizeof(cliaddr);
if((connfd = accept(listenfd , (struct sockaddr *)&cliaddr , &clilen)) < 0)
{
perror("accept error.\n");
exit(1);
}//if
printf("accpet a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr) , cliaddr.sin_port);
/*设置为非阻塞*/
setNonblocking(connfd);
ev.data.fd = connfd;
ev.events = EPOLLIN | EPOLLET;
epoll_ctl(epfd , EPOLL_CTL_ADD , connfd , &ev);
}//if
/*如果是已链接用户，并且收到数据，进行读入*/
else if(events[i].events & EPOLLIN){
if((sockfd = events[i].data.fd) < 0)
continue;
bzero(buf , MAX_LINE);
printf("reading the socket~~~\n");
if((n = read(sockfd , buf , MAX_LINE)) <= 0)
{
close(sockfd);
events[i].data.fd = -1;
}//if
else{
buf[n] = '\0';
printf("clint[%d] send message: %s\n", i , buf);
/*设置用于注册写操作文件描述符和事件*/
ev.data.fd = sockfd;
ev.events = EPOLLOUT| EPOLLET;
epoll_ctl(epfd , EPOLL_CTL_MOD , sockfd , &ev);
}//else
}//else
else if(events[i].events & EPOLLOUT)
{
if((sockfd = events[i].data.fd) < 0)
continue;
if((ret = write(sockfd , buf , n)) != n)
{
printf("error writing to the sockfd!\n");
break;
}//if
/*设置用于读的文件描述符和事件*/
ev.data.fd = sockfd;
ev.events = EPOLLIN | EPOLLET;
/*修改*/
epoll_ctl(epfd , EPOLL_CTL_MOD , sockfd , &ev);
}//else
}//for
}//while
free(events);
close(epfd);
exit(0);
}
扫一扫
1811
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
