socket编程之epoll多路复用

短命女 2022-09-24 13:20 204阅读 0赞

epoll的相关系统调用

1、int epoll\_create(int size);

创建一个epoll描述符，该描述符占用一个fd值，程序退出前必须调用close()关闭，参数size为最大监听事件数

2、int epoll\_ctl(int epfd, int op, int fd, struct epoll\_event \*event);

epoll的事件注册函数，它不同于select()是在监听事件时告诉内核要监听什么类型的事件，而要在监听之前先注册要监听的事件，函数成功调用返回0，失败返回-1

参数一epfd是epoll\_create返回的描述符

参数二op表示操作

EPOLL\_CTL\_ADD：注册新的fd到epfd中

EPOLL\_CTL\_DEL：从epfd中删除fd

EPOLL\_CTL\_MOD：修改已经注册到epfd的监听事件

参数三fd是要监听的fd

参数四event代表需要监听的事件类型，struct epoll\_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_data_t data;   
    };

events可以是以下几个宏的集合

EPOLLIN：对应的fd可读

EPOLLOUT：对应的fd可写

EPOLLPRI：对应的fd有紧急数据可读（这里应该表示有带外数据到来）

EPOLLERR：对应的fd出错

EPOLLHUP：对应的fd被挂断

EPOLLET：将EPOLL设为边缘出发（Edge Triggered）模式，这是相对水平触发（Level Triggered）来说的

EPOLLONESHOT：只监听一次，如果需要继续监听该socket，需再次把该socket加入EPOLL队列中

3、int epoll\_wait(int epfd, struct epoll\_event \*events, int maxevents, int timeout);

收集在epoll监听的事件中已经发生的事件

参数一epfd为epoll\_create返回的描述符

参数二events为一个已分配好内存的epoll\_event结构体数组，epoll会将已发生的事件存入该数组，events不能是NULL

参数三maxevents为events数组的大小

参数四timeout为超时时间，单位为毫秒，0表示立即返回，-1表示永久阻塞

函数成功调用返回对应I/O上已准备好的fd数目，失败返回-1，超时返回0

/*************************************************************************
     *  Copyright (C): 1540999272@qq.com
     *  Filename:      server.c
     *  Author:        Lu Zengmeng
     *  Description:   
     *  Creat Time:    2016-07-19 12:08
     ************************************************************************/
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <strings.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    #include <fcntl.h>
    #include <sys/stat.h>
    #include <time.h>
    #include <sys/epoll.h>
    
    #define PORT             8003
    #define BUF_LEN          128
    #define BACKLOG          5
    #define MAXEVENTS        50
    
    int    epoll_fd;
    struct epoll_event events[MAXEVENTS];
    
    void on_accept(int sock);
    void on_recv(int sock);
    
    int main(int argc, char *argv[])
    {
        int    sock_fd;
        int    yes = 1;
        int    timeout = 5000;
        int    ret;
        struct sockaddr_in     my_addr;
    
    
        bzero(&my_addr,sizeof(my_addr));
        my_addr.sin_family        = AF_INET;
        my_addr.sin_port          = htons(PORT);
        my_addr.sin_addr.s_addr   = INADDR_ANY;
    
    
        if (-1 == (sock_fd = socket(AF_INET, SOCK_STREAM, 0)))
        {
            perror("socket");
            exit(1);
        }
        
        if (-1 == setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)))
        {
            perror("setsockopt");
            exit(1);
        }
    
        if (-1 == bind(sock_fd, (struct sockaddr *)&my_addr, sizeof(my_addr)))
        {
            perror("bind");
            exit(1);
        }
    
        if (-1 == listen(sock_fd, BACKLOG))
        {
            perror("listen");
            exit(1);
        }
    
        printf("listenning...\n");
    
        epoll_fd = epoll_create(MAXEVENTS); // 创建epoll描述符
        if(epoll_fd < 0)
        {
            perror("epoll_create");
            exit(1);
        }
    
            struct epoll_event event;       //81~83 初始化需要监听的事件
        event.events = EPOLLIN|EPOLLET;
        event.data.fd = sock_fd;
    
        if(-1 == epoll_ctl(epoll_fd,EPOLL_CTL_ADD,sock_fd,&event)) // 注册监听事件
        {
            perror("epoll_ctl");
            exit(1);
        }
    
        while(1)
        {
            ret = epoll_wait(epoll_fd,events,MAXEVENTS,timeout); // 检查注册到epoll_fd中已发生的事件，并将发生的事件赋值到events数组中    
            if(ret < 0)
            {
                perror("epoll_wait");
                break;
            }
    
            if(ret == 0)
            {
                printf("timeout\n");
                continue;
            }
    
            int i;
            for(i=0;i<ret;i++)
            {
                if((events[i].events & EPOLLERR)||
                   (events[i].events & EPOLLHUP)||
                   (!(events[i].events & EPOLLIN)))
                {
                    printf("epoll error\n");
                    close(events[i].data.fd);
                    continue;
                }
    
                if(events[i].data.fd == sock_fd) // 发生sock_fd对应的事件说明有新的连接到来
                {
                    on_accept(sock_fd);
                }
                else
                {
                    on_recv(events[i].data.fd);
                }
            }
        }
    
        close(epoll_fd);
        close(sock_fd);
        return 0;
    }
    
    void on_accept(int sock)
    {
        int conn_fd;
        conn_fd = accept(sock,NULL,NULL);
    
        if(conn_fd < 0)
        {
            perror("accept");
            return;
        }
        else
            printf("new connection client[%d]\n",conn_fd);
    
        struct epoll_event event; //147~150 将新创建的连接注册到监听列表
        event.data.fd = conn_fd;
        event.events = EPOLLIN|EPOLLET;
        epoll_ctl(epoll_fd,EPOLL_CTL_ADD,conn_fd,&event);
    
        return;
    }
    
    void on_recv(int sock)
    {
        char    buf[BUF_LEN];
        int     ret = 0;
        int     len = 0;
    
        memset(buf,0,BUF_LEN);
        while(1)
        {
            ret =  recv(sock,buf+len,BUF_LEN-len,0);
            if(0 == ret)
            {
                len = 0;
                break;
            }
    
            else if(0 > ret)
            {
                len = 0;
                break;
            }
            
            len = len + ret;
    
            if(len < BUF_LEN)
            {
                continue;
            }
    
            else
            {
                printf("receive %s \n",buf);
                break;
            }
            
        }
        strcat(buf,"\0");
        printf("receive: %s from client[%d]\n",buf,sock);
    
        return;
    }