Linux系统编程之高并发服务器--epoll用法

epoll的用法：

epoll的使用主要在于三个函数。

epoll_create(int size);

创建一个epoll的句柄，size用来告诉内核这个监听的数目最大值。
注意：是数量的最大值，不是fd的最大值，切勿搞混。
当创建好epoll句柄后，它就是会占用一个fd值，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

  int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

epoll的事件注册函数。
epfd是epoll的句柄，即epoll_create的返回值；
op表示动作：用三个宏表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
fd是需要监听的套接字描述符；
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
};

events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，就会把这个fd从epoll的队列中删除。
如果还需要继续监听这个socket的话，需要再次把这个fd加入到EPOLL队列里**

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

等待事件的产生，返回需要处理的事件的数量，并将需处理事件的套接字集合于参数events内，可以遍历events来处理事件。
参数epfd为epoll句柄
events为事件集合
参数timeout是超时时间（毫秒，0会立即返回，-1是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

函数用法：

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>

#define maxsize 256

int main(int argc,char **argv)

{
        int i;
        if(argc !=3){

                printf("param is not good\n");
                exit(-1);

        }

        // 1.int socket(int domain, int type, int protocol);

        int sockfd=socket(AF_INET, SOCK_STREAM,0); //创建新的套接字描述符，建立socket对象
        if(sockfd==-1){
                perror("socket");
                exit(-1);
        }
        //2.  int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        struct sockaddr_in s_addr;  //保存服务器的信息
        memset(&s_addr,0,sizeof(s_addr));

        s_addr.sin_family=AF_INET;
        s_addr.sin_port=htons(atoi(argv[2]));
        inet_aton(argv[1],&s_addr.sin_addr);
        int ret=bind(sockfd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
        if(ret==-1)
        {
                perror("bind");
                exit(-1);
        }
        //3. int listen(int sockfd, int backlog); 设置监听队列 
        listen(sockfd,10);
 //int epoll_create(int size);

        int epfd=epoll_create(maxsize);
        if(epfd==-1){
                perror("epoll_create");
                exit(-1);
        }
        struct epoll_event ev;
        struct epoll_event events[maxsize]={0};
        ev.events=EPOLLIN;    //监听sockfd可读
        ev.data.fd=sockfd;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,sockfd,&ev);
        if(ret==-1)
        {
                perror("epoll_ctl");
                exit(-1);
        }
        //4. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        struct sockaddr_in c_addr;
        int clen=sizeof(struct sockaddr_in);
        char buf[32]={0};

        while(1)
        {
                int num=epoll_wait(epfd,events,maxsize,-1); //-1表示阻塞
                if(num==-1)
                {
                        perror("epoll_wait");
                        exit(-1);
                }
                for(i=0;i<num;i++)
                {
                        if(events[i].data.fd==sockfd)    //有客户端发起连接
                        {
                                int fd=accept(sockfd,(struct sockaddr *)&c_addr,&clen);
                                if(fd==-1)
                                {
                                        perror("accept");
                                        exit(-1);
                                }
                                printf("接受来自%s的连接fd=%d\n", inet_ntoa(c_addr.sin_addr),fd);
                                //  为新的文件描述符注册事件
                                ev.data.fd=fd;
                                ev.events=EPOLLIN;
                                ret=epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev);
       if(ret==-1)
                                {
                                        perror("epoll_ctl");
                                }
                        }
                        else
                        {
                                if(events[i].events & EPOLLIN)  //如果事件是可读的
                                {
                                        ret=recv(events[i].data.fd,buf,sizeof(buf),0);
                                        if(ret==-1)
                                        {
                                                perror("rev");
                                        }
                                        else if(ret==0)
                                        {
                                                ev.data.fd=events[i].data.fd;
                                                ev.events=EPOLLIN;
                                                epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,&ev);
                                        }
                                        else
                                        {
                                                printf("收到%d客户端的消息%s\n",events[i].data.fd,buf);
                                        }
                                        memset(buf,0,sizeof(buf));

                                }
                        }
                }

        }

        return 0;

}