监视多个socket描述符简单方法-selcet
函数原型：
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds,struct timeval *timeout)；
宏操作fd_set集合：
void FD_CLR(int fd, fd_set *set);清除位图set（描述符集合）中的fd
int FD_ISSET(int fd, fd_set *set);判断fd是否在集合中；
void FD_SET(int fd, fd_set *set);将fd添加到集合中去；
void FD_ZERO(fd_set *set); 将集合set清空成0；
select原理：
1、select同时监视llisten_fd等fd_set集合中的所有描述符，调用select处理后，操作系统将进程加入listen_fd等所有socket描述符的等待队列，进程由运行态转到等待态|
2、只要listen_fd有新数据到达，系统中断唤醒进程，进程由等待态转到运行态（也即将该进程从等待队列移除，加入到运行队列中）
3、进程被唤醒后，进程便知道有数据到达，开始便遍历fd_set集合，若为listen_fd数据，则创建新连接，并将该连接加入集合。若为普通fd数据，则调用recv等操作。
select缺点：
1、轮询方式涉及两次遍历集合：一次为，select被置于死循环中，每调用select都涉及进程等待到运行队列的相互切换，将进程分别加入每个fd描述符的等待队列中。另一次为数据到达select返回时不返回具体是哪个描述符有数据到达，需要遍历集合由FD_ISSET找到具体是哪一个描述符有数据到达。
2、每次遍历都需将整个集合传递给内核，集合越大，速度越慢，代价就越大。
3、出于对效率的考虑，32位linux下默认最大监听数是32x32即1024个，操作系统位数的32倍。可以修改内核头文件#define _FD_SETSIZE 1024的值，但需要重新编译内核，就又涉及到其他一些问题了。注意，此最大描述符限制为单个进程内的限制。
补充说明poll：
poll的原理与select基本类似，只不过select描述符集合是以顺序数组实现，poll是以链表实现。传入时不需要传参数数组，可监听的描述符不局限于1024，可通过cat /proc/sys/fs/file-max查看。缺点是仍然不能指明是哪个socket数据到达。
一个简单的server例子：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
/*
* 初始化监听socket描述符
* */
int init_listen_socket(short port) {
int listen_fd;
int ret;
struct sockaddr_in server_addr;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0) {
fprintf(stderr, "fail to socket : %s\n", strerror(errno));
return -1;
}
// 配置listen_fd的TIME_WAIT时可复用
int on = 1;
ret = setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (ret == -1) {
perror("set sock reuse addr:");
return -1;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
ret = bind(listen_fd, (struct sockaddr *) &server_addr, sizeof(server_addr));
if (ret < 0) {
perror("fail to bind");
return -1;
}
listen(listen_fd, 5);
return listen_fd;
}
//接受新连接
void chat_loop(int listen_fd)
{
fd_set current, bak;
int maxfd;
int ret;
int i;
int new_fd;
char buf[128];
FD_ZERO(¤t);
FD_SET(listen_fd, ¤t);//将监听描述符加入用户态集合
maxfd = listen_fd;
while (1) {
bak = current;//内核拷贝
ret = select(maxfd+1,&bak,NULL,NULL,NULL);
if(ret < 0) {
perror("select");
return ;
}
for (i = 0; i <= maxfd; i++) {
//新连接处理
if(FD_ISSET(i, &bak)) {
if( i == listen_fd) {
new_fd = accept(listen_fd, NULL, NULL);
if (new_fd < 0) {
perror("fail to accept");
break;
}
FD_SET(new_fd, ¤t);
if ( new_fd > maxfd ) {
maxfd = new_fd;
}
printf("new conncection success!\n");
}
//普通fd数据处理
else {
memset(buf, 0, sizeof(buf));
ret = recv(i, buf, sizeof(buf), 0);
if (ret == 0) {
close(i);
FD_CLR(i, ¤t);
continue;
}
buf[ret] = 0;
printf("recv: %s\n", buf);
}
}
}
}
}
int main(int argc, char *argv[])
{
int listen_fd;
int new_fd;
char buf[1024];
int ret;
unsigned short port = 8888;
if (argc == 2) {
port = strtoul(argv[1], NULL, 10);
}
listen_fd = init_listen_socket(port);
if (listen_fd == -1) {
exit(-1);
}
printf("listen %d port...\n", port);
chat_loop(listen_fd);
return 0;
}
更高并发的epoll
函数原型：
int epoll_create(int size);创建一个eopll对象，返回值是该对象的描述符
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);//操作epoll对象，添加或删除。
int epoll_wait(int epid, struct epoll_event *events, int maxevents, int timeout);//阻塞进程，并等待事件的发生
epoll的原理：
1、进程调用epoll_create，内核会创建一个epoll对象，用一个epoll对象代表所有socket描述符。它也是文件系统的一员。内核需维护就序队列等待数据到来，就绪队列就可以作为epoll的成员
2、有了epoll对象，通过epoll_ctl实现对socket描述符的添加和删除。实际上当数据到达后，中断程序操作epoll对象，不直接操作进程。
3、socket数据到达，中断程序给epoll的就绪列表添加socket引用，即是让epoll对象的成员rdlist引用这些socket。
4、进程一直进行到epoll_wait，若rdlist引用了socket，则epoll_wait直接返回，若rdlist为空，阻塞该进程。
进程的阻塞和唤醒：进程运行到epoll_wait时，内核将进程A放入epoll对象的等待队列，阻塞该进程。知道socket有数据到达，中断程序修改对象的rdlist，且还将对象中等待队列中的进程切换到运行状态。由于rdlist表示的是可读列表，且是直接引用的socket，所以进程可以直接知道哪个socket有数据到达。
epoll对象数据结构
struct eventpoll{
spinlock_t lock;
struct mutex mtx;
wait_queue_head_t wq;//epoll_wait维护的等待队列
wait_queue_head_t poll_wait;
struct list_head rdlist;//就绪队列，双向链表中则存放着将要通过epoll_wait返回给用户的满足条件的事件
struct rb_root rbr;//红黑树树根，存放所有当前包括的struct epitem
struct epitem *ovlist;
struct user_struct *user;
struct file *file;
int visited;
struct list_head visited_list_link;
}
其中我们重点关注的是就序列表rdlist和红黑树rbr索引结构。
通过epoll_ctl向epoll对象中添加一些socket事件，这些事件都会挂在到rbr红黑树中。红黑树方便添加、移除，且搜索也是高效的。搜索、插入、删除的时间复杂度都是O(log(N))。
注意：rdlist并不是直接引用了socket，而是通过epitem间接引用，struct epitem 记录的是整个事件信息，以事件为单位，不以单个socket描述符。红黑树的节点是epitem对象
struct epitem{
struct rb_node rbn;//将epitem添加到eventpoll红黑树中
struct list_head rdllink;//将epitem添加到eventpoll就绪链表中
struct epitem *next;
struct epoll_filefd ffd;//表示添加到eventpoll的文件
int nwait;//等待队列大小
struct list_head pwqlist;//等待队列链表
struct eventpoll *ep;//epitem所属的eventpoll
struct list_head fllink;
struct epoll_event event;
}
两种触发方式：
边沿触发(ET)：当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据全部读写完(如读写缓冲区太小)，那么下次调用epoll_wait()时，它不会通知你，也就是它只会通知你一次，直到该文件描述符上出现第二次可读写事件才会通知你
水平触发(LT)：当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据一次性全部读写完(如读写缓冲区太小)，那么下次调用 epoll_wait()时，它还会通知你在上次没读写完的文件描述符上继续读写
可理解为0101脉冲方波触发的边沿触发以及水平触发模式。
epoll优点：
1、对于并发处理最大描述符数无限制，理论上大小的1g内存就可支持10万连接量。但他实际受系统进程打开最大文件描述符限制，其一般为65535
2、高效，只要有就绪事件发生，描述符对应的回调函数将其添加到rdlist。返回就绪队列描述符给用户。
服务端简单例子：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
/*
* 初始化监听socket描述符
* */
int init_listen_socket(short port) {
int listen_fd;
int ret;
struct sockaddr_in server_addr;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0) {
fprintf(stderr, "fail to socket : %s\n", strerror(errno));
return -1;
}
// 配置listen_fd的TIME_WAIT时可复用
int on = 1;
ret = setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (ret == -1) {
perror("set sock reuse addr:");
return -1;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
ret = bind(listen_fd, (struct sockaddr *) &server_addr, sizeof(server_addr));
if (ret < 0) {
perror("fail to bind");
return -1;
}
listen(listen_fd, 5);
return listen_fd;
}
void chat_loop(int listen_fd)
{
int epoll_fds;
int nfds;
int i;
int new_fd;
char buf[1024];
int ret;
struct epoll_event ev, events[1024];
// 1. 产生epoll的实例化对象
epoll_fds = epoll_create(1024);
if (epoll_fds < 0) {
perror("epoll create");
return ;
}
// 2. 向epoll对象添加你要监听的描述符
ev.events = EPOLLIN;
ev.data.fd = listen_fd;
if (epoll_ctl(epoll_fds, EPOLL_CTL_ADD, listen_fd, &ev) == -1) {
perror("epoll_ctl: listen_sock");
return ;
}
// 3. 循环等待事件的发生，进行事件的处理
while (1) {
nfds = epoll_wait(epoll_fds, events, 1024, -1);//返回可读sockfd个数
if (nfds == -1) {
perror("epoll wait");
break;
}
for (i = 0; i < nfds; i++) {
// 根据不同的时间注册值来决定进行怎样的事件处理
if(events[i].data.fd == listen_fd) {
new_fd = accept(listen_fd, NULL, NULL);
if (new_fd < 0) {
perror("fail to accept");
break;
}
ev.events = EPOLLIN;
ev.data.fd = new_fd;
if (epoll_ctl(epoll_fds, EPOLL_CTL_ADD, new_fd, &ev) == -1) {
perror("epoll_ctl: new_sock");
continue;
}
printf("Have a new connection!\n");
}
else {
memset(buf, 0, sizeof(buf));
ret = recv(events[i].data.fd, buf, sizeof(buf), 0);
if (!ret) {
epoll_ctl(epoll_fds, EPOLL_CTL_DEL, events[i].data.fd, NULL);
close(new_fd);
printf("close connection!\n");
}
buf[ret] = 0;
printf("recv: %s\n", buf);
}
}
}
}
int main(int argc, char *argv[])
{
int listen_fd;
int new_fd;
char buf[1024];
int ret;
unsigned short port = 8888;
if (argc == 2) {
port = strtoul(argv[1], NULL, 10);
}
listen_fd = init_listen_socket(port);
if (listen_fd == -1) {
exit(-1);
}
printf("listen %d port...\n", port);
chat_loop(listen_fd);
return 0;
}
客户端测试例子：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
int init_client(struct sockaddr_in dest)
{
int client_fd;
int ret;
// 初始化TCP客户端连接
client_fd = socket(AF_INET, SOCK_STREAM, 0);
if (client_fd < 0) {
fprintf(stderr, "<get file>:Socket Fail: %s\n", strerror(errno));
return -1;
}
ret = connect(client_fd, (struct sockaddr *)&dest, sizeof(dest));
if (ret < 0) {
fprintf(stderr, "<get file>:Connect Fail: %s\n", strerror(errno));
close(client_fd);
return -1;
}
printf("connect server success!\n");
return client_fd;
}
int main(int argc, char *argv[])
{
int client_fd;
struct sockaddr_in server_addr;
char buf[1024];
if (argc < 3) {
printf("Usage : %s <server_ip> : <port>\n", argv[0]);
exit(-1);
}
// 初始化服务器地址信息
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = PF_INET;
server_addr.sin_port = htons(strtoul(argv[2], NULL, 10));
server_addr.sin_addr.s_addr = inet_addr(argv[1]);
client_fd = init_client(server_addr);
if (client_fd < 0) {
fprintf(stderr, "<get file>:Socket Fail: %s\n", strerror(errno));
return -1;
}
printf("<client>: ");
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf)-1, stdin);
buf[strlen(buf) - 1] = 0;
while ( strncmp(buf, "quit", 4) != 0 ) {
send(client_fd, buf, strlen(buf), 0);
printf("<client>: ");
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf)-1, stdin);
buf[strlen(buf) - 1] = 0;
}
printf("close chat!\n");
close(client_fd);
}
总结
| 方式 | select | poll | epoll |
|---|---|---|---|
| 遍历方式 | 通过初始化一个集合数组存储所有socket，当有数据到达时，需要遍历这个集合 | 跟select类似，只不过用链表实现对所有socket的管理，也需要遍历 | 只需关心一个epoll实例化对象，epoll对象的内部工作完成对所有socket事件的管理，至于如何操作，交给操作系统处理就好了。当epoll_wait返回可读时，我们直接操作可读的socket即可 |
| 时间复杂度 | O(n) | O(n) | O(1) |
| 连接限制 | 一般为1024 | 65535 | 65535 |
总的看来，epoll比select更高效的实现大量并发，但是select一定比epoll更高效吗？实际上，select适用于连接数少，活动连接多的情况。epoll适用于连接数多，活动连接少的情况。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
