poll->epoll服务器

本文对比了poll与select机制,介绍了poll的优点如文件描述符数量不受限及输入输出参数分离,并指出了其性能瓶颈。重点讲解了epoll在Linux 2.6中的高效性,包括底层回调机制、红黑树维护、就绪队列快速访问等,并提供了基于LT与ET模式下的epoll示例代码。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

poll

相对于select来说,poll的优点:
1)能监视的文件描述符的数量没有限制
2)poll输入和输出参数不是同一变量,输入和输出分离
缺点:
1)和select一样,监视的文件描述符过多时,后序也许需要进行遍历式访问,性能也会下降。(为了解决这个问题所以用到了epoll)
makefile

mypoll:mypoll.c
    gcc -o $@ $^
.PHONY:clean
clean:
    rm -f mypoll

mypoll

#include <stdio.h>
#include <poll.h>


int main()
{
    struct pollfd ev;
    ev.fd = 0;
    ev.events = POLLIN;
    ev.revents = 0;

    int timeout = -1;
    while(1)
    {
        switch(poll(&ev,1,timeout))
        {
            case 0:
                sleep(1);
                printf("timeout...\n");
                break;
            case -1:
                perror("poll");
                break;
            default:
                {
                    char buf[1024];
                    if(ev.fd == 0&& ev.revents & POLLIN)
                    {
                        ssize_t s = read(0,buf,sizeof(buf)-1);
                        if(s>0)
                        {
                            buf[s-1] = 0;
                            printf("echo %s\n",buf);
                        }
                    }

                }
                break;
        }
    }
    return 0;
}

epoll

linux2.6下epoll是多路转接性能最好的
高效的原因:
1.底层采用回调机制来激活所关心的结点
2.维护所关心的文件描述符以及对应事件采用红黑树,进而可以减少维护该数据结构增删查改的成本
3.事件一旦就绪,相干事件发送到就绪队列,当上层epoll _wait在获取时可以以O1时间复杂度获取有效事件。
4.就绪队列用户到内核区采用内存映射机制,减少数据拷贝次数
5.就绪时间的陈列方式是从0下标开始连续陈列,避免了数据重复拷贝的问题

eopll的三个接口:
epoll_create 调用它会在底层创建一颗空的红黑树(只有根,没有结点)并维护就绪队列
epoll_ctl 可以向红黑树中添加或释放结点
epoll_wait 返回要关心的事件中哪些已经就绪(底层采用回调机制激活结点(激活方式有两种:LT水平触发(总是通知)和ET边沿触发(只通知一次))并放在就绪队列(队列是有顺序的,从左往右)中)

makefile

myepoll:myepoll.c
    gcc -o $@ $^
.PHONY:clean
clean:
    rm -f myepoll

基于LT模式下的epoll

myepoll

#include <stdio.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>





#define SIZE 64

const char *msg ="HTTP/1.0 200 OK\r\n\r\n<html><h1>chao ge!</h1></html>\r\n";


static void usage(const char *proc)
{
    printf("Usage:\n\t%s [local_ip] [local_port]\n\n",proc);
}


int startup(const char *ip, int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }

    int opt = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));//设置端口复用



    struct sockaddr_in local;
    local.sin_family =AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);
    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);

    }
    if(listen(sock, 10))
    {
        perror("listen");
        exit(4);
    }
    return sock;
}


int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;

    }
    int listen_sock = startup(argv[1],atoi(argv[2]));
    int epfd = epoll_create(256);//创建模型
    if(epfd < 0)
    {
        perror("epoll_create");
        return 5;
    }
    printf("listen_sock: %d, epfd: %d\n",listen_sock,epfd);
    struct epoll_event ev;
    ev.events =EPOLLIN;//LT
    ev.data.fd = listen_sock;
    epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&ev);
    int nums = -1;
    int timeout =-1;
    struct epoll_event revs[SIZE];//返回的事件集
    while(1)
    {
        switch((nums = epoll_wait(epfd,revs,SIZE,timeout)))
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("epoll_wait");
                break;
            default:
                {
                    //at least one fd ready!
                    int i =0;
                    for(;i < nums;i++)
                    {
                        int fd =revs[i].data.fd;
                        if(fd == listen_sock &&(revs[i].events &EPOLLIN))
                        {
                            //listen_sock ready!
                            struct sockaddr_in client;
                            socklen_t len =sizeof(client);
                            int rw_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
                            if(rw_sock < 0)
                            {
                                perror("accept");
                                continue;
                            }
                            printf("get a new client [%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                            ev.events = EPOLLIN;
                            ev.data.fd = rw_sock;
                            epoll_ctl(epfd,EPOLL_CTL_ADD,rw_sock,&ev);


                        }
                        else if(fd!= listen_sock)
                        {
                            //normal fd rw events ready!
                            if(revs[i].events &EPOLLIN)
                            {
                                //read
                                char buf[4096];
                                ssize_t s = read(fd,buf,sizeof(buf)-1);
                                if(s>0)
                                {
                                    buf[s] = 0;
                                    printf("client# %s\n",buf);
                                    ev.events =EPOLLOUT;
                                    ev.data.fd = fd;
                                    epoll_ctl(epfd,EPOLL_CTL_MOD,fd,&ev);
                                }
                                else if(s == 0)
                                {
                                    printf("client is quit!\n");
                                    close(fd);
                                    epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);

                                }
                                else
                                {
                                    perror("read");
                                    close(fd);
                                    epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);

                                }

                            }
                            else if(revs[i].events &EPOLLOUT)
                            {
                                //write
                                write(fd,msg,strlen(msg));
                                close(fd);
                                epoll_ctl(epfd,EPOLL_CTL_DEL\
                                ,fd,NULL);

                            }
                            else
                            {

                            }

                        }
                        else
                        {

                        }

                    }
                }
                break;

        }
    }
    close(epfd);
    return 0;


}

基于ET模式下的epoll

#include <stdio.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <fcntl.h>
#define SIZE 64

typedef struct fd_buff//为每一个文件描述符设置一个缓冲区
{
    int fd;
    char buf[4096];
    int step;



}fd_buff_t,*fd_buff_p,**fd__buff__pp;

fd_buff_p alloc_buff(int sock)
{
    fd_buff_p tmp =(fd_buff_p)malloc(sizeof(fd_buff_t));
    if(!tmp)
    {
        return NULL;
    }
    tmp->fd = sock;
    tmp->step = 0;
}

void delete_buff(fd_buff_p fp)
{
    if(fp)
    {
        free(fp);
    }
}


const char *msg ="HTTP/1.0 200 OK\r\n\r\n<html><h1>chao ge!</h1></html>\r\n";


static void usage(const char *proc)
{
    printf("Usage:\n\t%s [local_ip] [local_port]\n\n",proc);
}


int startup(const char *ip, int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }

    int opt = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));



    struct sockaddr_in local;
    local.sin_family =AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);
    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);

    }
    if(listen(sock, 10))
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

int set_nonblock(int fd)
{
    int fl = fcntl(fd,F_GETFL);//获得文件描述符的标志位信息(确定它是阻塞还是非阻塞)
    fcntl(fd,F_SETFL,fl|O_NONBLOCK);//再调用fcntl通过F_SETFL设置其描述符,为其添加一个选项:O_NONBLOCK(非阻塞)
}



int myread(int fd,char *buf,int size)
{
     //循环读(一次读不完)
     ssize_t len = 0;//当前长度
     ssize_t total = 0;//总共读的数据
     while((len = read(fd,buf+total,8))> 0&&len ==8)
     {

        total +=len;
        if(len < 8)
         {
            break;
         }
     }

}



int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;

    }
    int listen_sock = startup(argv[1],atoi(argv[2]));
    set_nonblock(listen_sock);//设置套接字为非阻塞
    int epfd = epoll_create(256);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 5;
    }
    printf("listen_sock: %d, epfd: %d\n",listen_sock,epfd);
    struct epoll_event ev;
    ev.events =EPOLLIN|EPOLLET;// |epollet设置为ET模式(默认为LT)
    ev.data.ptr = alloc_buff(listen_sock);
    epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&ev);
    int nums = -1;
    int timeout =-1;
    struct epoll_event revs[SIZE];
    while(1)
    {
        switch((nums = epoll_wait(epfd,revs,SIZE,timeout)))
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("epoll_wait");
                break;
            default:
                {
                    //at least one fd ready!
                    int i =0;
                    for(;i < nums;i++)
                    {
                        int fd =((fd_buff_p)(revs[i].data.ptr))->fd;
                        if(fd == listen_sock &&(revs[i].events &EPOLLIN))
                        {
                            //listen_sock ready!
                            struct sockaddr_in client;
                            socklen_t len =sizeof(client);
                            int rw_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
                            if(rw_sock < 0)
                            {
                                perror("accept");
                                continue;

                            }
                            printf("get a new client [%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                            set_nonblock(rw_sock);
                            ev.events = EPOLLIN|EPOLLET;
                            ev.data.ptr = alloc_buff(rw_sock);
                            epoll_ctl(epfd,EPOLL_CTL_ADD,rw_sock,&ev);


                        }
                        else if(fd!= listen_sock)
                        {
                            //normal fd rw events ready!
                            if(revs[i].events &EPOLLIN)
                            {
                                //read
                                char buf[4096];
                                ssize_t s = myread(fd,buf,sizeof(buf)-1);
                                if(s>0)
                                {
                                    buf[s] = 0;
                                    printf("client# %s\n",buf);
                                    ev.events =EPOLLOUT|EPOLLET;
                                    ev.data.ptr = revs[i].data.ptr;
                                    epoll_ctl(epfd,EPOLL_CTL_MOD,fd,&ev);
                                }
                                else if(s == 0)
                                {
                                    printf("client is quit!\n");
                                    close(fd);
                                    epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);
                                    delete_buff(revs[i].data.ptr);

                                }
                                else
                                {
                                    perror("read");
                                    close(fd);
                                    epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);

                                }

                            }
                            else if(revs[i].events &EPOLLOUT)
                            {
                                //write
                                write(fd,msg,strlen(msg));
                                close(fd);
                                epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);

                            }
                            else
                            {

                            }

                        }
                        else
                        {

                        }

                    }
                }
                break;

        }
    }
    return 0;


}
### C语言 Socket 函数使用地址族初始化文件描述符 #### 创建Socket并初始化文件描述符 `socket()` 是用于创建套接字的函数,其功能是分配一个文件描述符给调用者,并将其绑定到指定的协议栈上。以下是 `socket()` 的基本语法及其参数解释: ```c int socket(int domain, int type, int protocol); ``` - **domain**: 指定协议族,常见的有: - `AF_INET`: IPv4 地址族。 - `AF_INET6`: IPv6 地址族。 - `AF_UNIX`, `AF_LOCAL`: 本地套接字通信(进程间通信)。[^3] - **type**: 指定通信过程中使用的协议类型: - `SOCK_STREAM`: 面向连接的流式协议,默认使用 TCP。 - `SOCK_DGRAM`: 面向无连接的数据报协议,默认使用 UDP。 - **protocol**: 指定具体的协议编号。通常情况下可以传入 `0`,表示由系统自动选择合适的协议。如果指定了 `SOCK_STREAM` 类型,则会默认使用 TCP;如果是 `SOCK_DGRAM` 则默认使用 UDP。 - **返回值**: - 成功时返回一个有效的文件描述符,该描述符可用于后续的操作(如 bind、listen、accept 等)。 - 如果发生错误则返回 `-1` 并设置相应的 errno 值。 下面是一个简单的代码示例,展示如何使用 `socket()` 来创建一个基于 IPv4 和 TCP 协议的套接字: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #define PORT 8080 int main() { // 定义变量 int sockfd; struct sockaddr_in server_addr; // 调用 socket() 函数创建套接字 if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("Socket creation failed"); exit(EXIT_FAILURE); } printf("Socket created successfully\n"); // 设置服务器地址结构 memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; // 使用 IPv4 地址族 server_addr.sin_port = htons(PORT); // 绑定端口 server_addr.sin_addr.s_addr = INADDR_ANY; // 接受来自任何 IP 地址的请求 // 进行其他操作... close(sockfd); return 0; } ``` 上述代码中,我们通过 `socket()` 函数创建了一个面向连接的流式套接字 (`SOCK_STREAM`),它运行于 IPv4 地址族下 (即 `AF_INET`)。如果成功执行此语句,则意味着已获得一个新的文件描述符来代表这个新建立起来的网络资源对象——也就是所谓的“套接口”。[^1] #### 可能遇到的问题及解决方法 当尝试利用管道机制跨不同进程共享文件描述符时可能会出现问题。例如,在某些实现里直接把某个打开文件或者设备对应的整数形式FD号发送过去并不能真正达到目的,这是因为每个独立运行中的程序实例都有各自维护的一组映射表项用来跟踪这些抽象概念的实际位置所在之处。因此单纯依靠复制数值是没有意义的行为。应该采用专门设计好的API比如UNIX Domain Sockets所提供的辅助工具来进行此类任务处理工作。[^4] 另外需要注意的是,在实际开发当中还存在诸如超时时长控制不当等问题也可能引起应用程序挂起等待响应等情况的发生。对于这种情况可以通过调整套接字选项状态标志位的方式加以改善优化性能表现效果更佳一些。具体做法如下所示: ```c // 设置非阻塞模式 if(ioctl(socket_fd, FIONBIO, (char *)&nonblock_flag) != 0){ perror("ioctl error"); } // 或者使用 fcntl 方法改变属性 flags = fcntl(socket_fd, F_GETFL, NULL); fcntl(socket_fd, F_SETFL, flags | O_NONBLOCK); ``` 随后再配合 select/poll/epoll 系统调用完成多路复用监听事件检测逻辑流程即可有效规避长时间停滞现象再次重现风险隐患。同时也可以借助 getsockopt API 查询当前链接状况从而进一步确认是否存在异常中断情形以便及时采取相应补救措施恢复正常的业务运转秩序恢复正常服务提供能力水平标准之上保持稳定高效持续运作下去满足预期目标需求达成共识共赢局面形成良性循环发展态势向前迈进一大步取得更大成就成果辉煌灿烂明天更加美好幸福安康生活充满希望憧憬未来无限可能空间广阔天地任鸟飞鱼跃海阔天空尽情翱翔追逐梦想勇往直前永不言弃坚持到底就是胜利!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值