使用epoll 实现TCP并发服务器

epoll简介

#include 
int epoll_create(int size);
功能：创建epoll
参数：
    @size:参数已经被忽略了，只需要填写大于0的值即可
返回值：成功返回epfd,失败返回-1置位错误码

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
功能：关于epoll的控制操作
参数：
    @epfd:epoll的文件描述符
 @op:控制方式
        EPOLL_CTL_ADD：添加
        EPOLL_CTL_MOD：修改
        EPOLL_CTL_DEL：删除
 @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;      //EPOLLIN 读  EPOLLOUT 写
               epoll_data_t data;        //存放用户的数据
           };
返回值：成功返回0，失败返回-1置位错误码

int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
功能：阻塞等待文件描述符就绪
参数：
    @epfd:epoll的文件描述符
    @events:准备好的事件的结构体地址
 @maxevents:返回的最大的文件描述符的个数
    @timeout:超时
        >0 :毫秒级别的超时时间
        =0 :立即返回
        =-1:不关心超时时间
返回值：
     成功返回准备好的文件描述符的个数
     返回0代表超时时间到了
     失败返回-1置位错误码

服务器代码

//服务器代码

#include 
#include 
#include 
#include  /* superset of previous */
#include 
#include 
#include 
#include 
#include 
#include  /* See NOTES */
#include 
#define ERRLOG(msg)                                        \
    do {                                                   \
        printf("%s %s %d:", __FILE__, __func__, __LINE__); \
        perror(msg);                                       \
        exit(-1);                                          \
    } while (0)
#if 0
使用epoll完成并发服务器模型：
1、创建红黑树
2、将关心的文件描述符加入红黑树上
3、等待发生IO事件的文件描述符
4、判断哪个文件描述符发生了IO事件并且作出对应逻辑处理
#endif
#define N 32
int main(int argc, char* argv[])
{
    // 1.创建红黑树
    int epfd = epoll_create(1);
    if (epfd < 0) {
        ERRLOG("epfd err");
    }
    // 2.创建套接字
    int socketfd;
    if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))) {
        ERRLOG("socket error");
    }
    // 2.struct epoll_event event
    // EPOLL_CTL_ADD: //  将关心的文件描述符加入到红黑树上
    // EPOLLIN  :可读事件
    // EPOLLET：边沿检测
    // 初始化对应文件描述符

    struct epoll_event event;
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = socketfd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, socketfd, &event) < 0) {
        ERRLOG("epoll_ctl error");
    }
    // 填充服务器地址
    struct sockaddr_in serveraddr, clientaddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);
    socklen_t clientaddr_len = sizeof(clientaddr_len);
    // 绑定
    if (bind(socketfd, (struct sockaddr*)&serveraddr, serveraddr_len) < 0) {
        ERRLOG("bind error");
    }
    // 监听
    if (listen(socketfd, 10) < 0) {
        ERRLOG("listen error");
    }
    int acceptfd, ret, i;
    int bytes;
    struct epoll_event events[20];
    char buf[N] = { 0 };
    while (1) {
        // 3.使用epoll_wait轮询检测文件描述赋发生IO事件
        ret = epoll_wait(epfd, events, 20, -1);
        if (ret > 0) {
            for (i = 0; i < ret; i++) {
                // 判断文件描述符数值
                if (events[i].data.fd == socketfd) {
                    // 判断对应文件描述符的IO类型
                    if (events[i].events & EPOLLIN == EPOLLIN) {
                        acceptfd = accept(events[i].data.fd, (struct sockaddr*)&clientaddr, &clientaddr_len);
                        if (acceptfd < 0) {
                            ERRLOG("accept error");
                        }
                        printf("IP:%s 连接成功\n", (char*)inet_ntoa(clientaddr.sin_addr));
                        // 将新客户端通信套接字挂到树上
                        struct epoll_event event;
                        event.events = EPOLLIN | EPOLLET;
                        event.data.fd = acceptfd;
                        if (epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &event) < 0) {
                            ERRLOG("epoll_ctl err");
                        }
                    }
                } else {
                    // 处理老客户端信息
                    if (EPOLLIN & events[i].events == EPOLLIN) {
                        memset(buf, 0, sizeof(buf));
                        if (-1 == (bytes = recv(events[i].data.fd, buf, sizeof(buf), 0))) {
                            ERRLOG("recv error");
                        } else if (bytes == 0) {
                            // 客户端断开信息
                            printf("acceptfd:%d 断开连接...\n", events[i].data.fd);
                            // 关闭对应文件描述符
                            close(events[i].data.fd);
                            // 将挂在树上对应的文件描述符清楚
                            epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                        } else {
                            printf("buf:%s\n", buf);
                        }
                        strcat(buf, "--hqyj");
                        if (-1 == send(events[i].data.fd, buf, N, 0)) {
                            ERRLOG("send error");
                        }
                    }
                }
            }
        } else {
            ERRLOG("epoll_wait error");
        }
    }
    close(socketfd);
    return 0;
}

 客户端代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define ERRLOG(msg)                                        \
    do {                                                   \
        printf("%s %s %d:", __FILE__, __func__, __LINE__); \
        perror(msg);                                       \
        exit(-1);                                          \
    } while (0)

#define N 32

int main(int argc, const char* argv[])
{
    //入参合理性检查
    if (3 != argc) {
        printf("Usage : %s  \n", argv[0]);
        return -1;
    }

    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        ERRLOG("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);

    socklen_t serveraddr_len = sizeof(serveraddr);

    char buf[32] = { 0 };
    int nbytes = 0;

    // 3.尝试与服务器建立连接
    if (-1 == connect(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        ERRLOG("connect error");
    }
    printf("与服务器建立连接成功..\n");
    while (1) {
        memset(buf, 0, sizeof(buf));
        fgets(buf, N, stdin);
        buf[strlen(buf) - 1] = '\0'; //清理结尾的\n

        //发送数据
        if (-1 == send(sockfd, buf, sizeof(buf), 0)) {
            ERRLOG("send error");
        }
        //接收服务器的应答信息
        if (-1 == (nbytes = recv(sockfd, buf, sizeof(buf), 0))) {
            ERRLOG("recv error");
        }
        if (0 == nbytes) {
            break;
        }
        //输出应答信息
        printf("应答为:[%s]\n", buf);
    }
    //关闭套接字
    close(sockfd);

    return 0;
}