网络编程---select、poll、epoll服务器编写

最新推荐文章于 2024-03-15 11:04:54 发布
最新推荐文章于 2024-03-15 11:04:54 发布
阅读量515 收藏 1
点赞数
分类专栏： linux 网络编程 文章标签： select poll epoll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_xiaoye/article/details/80713507
版权

select服务器

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>                                                                                                                  
#include <sys/select.h>
#include <sys/socket.h>

#define MAX_FD sizeof(fd_set)*8  //需要进行等待的文件描述符数组最大值
#define INIT -1                  //文件描述符数组初始化值

//文件描述符数组初始化
void AddryInit(int array[], int num )
{
    int i = 0;
    for(; i < num; ++i)
    {
        array[i] = INIT;
    }
}
//往文件描述符数组中添加新的需要等待的文件描述符
void AddryAdd(int array[], int num ,int fd) 
{
    int i = 0;
    for(; i < num; ++i)
    {   
        if(array[i] == INIT)
        {   
            array[i] = fd; 
            return;
        }   
    }   
}
//往可读文件描述符集中添加文件描述符
int ReadFdSet(int listen_sock, int array[], int num , fd_set* read_set)
{
    int i = 0;
    FD_SET(listen_sock, read_set);
    int max = listen_sock;
    for(; i < num; ++i)
    {
        if(array[i] != INIT)
        {
            FD_SET(array[i], read_set);
            if(max < array[i])
            {
                max = array[i];
            }
        }
    }
    return max;
}
//绑定端口号，将套接字设置为监听状态
int StartUp(int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = INADDR_ANY;                                                                                                 
    socklen_t len = sizeof(local);
    if(bind(sock,(struct sockaddr*)&local, len) < 0)
    {
        perror("bind");
        exit(2);
    }
    if(listen(sock,5) < 0)
    {
        perror("listen");
        exit(3);
    }

    return sock;
}
//从文件描述符数组中删除文件描述符
void AddryDel(int array[], int num, int i)
{
    if(i < num)
    {
        array[i] = INIT;
    }
}
//服务函数
void Service(int listen_sock,fd_set* read_set, int array[],int num)
{
    int i = 0;
    for(; i < num ; ++i)
    {
        if(array[i] != INIT && FD_ISSET(array[i],read_set))
        {
            if(array[i] == listen_sock)
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int client_sock = accept(listen_sock,(struct sockaddr*)&client, &len);                                                  
                if(client_sock < 0)
                {
                    perror("accept");
                                        continue;
                }
                AddryAdd(array,num,client_sock);
            }
            else
            {
                char buf[1024];
                ssize_t s = read(array[i], buf, sizeof(buf)-1);
                if(s > 0)
                {
                    buf[s] = 0;
                    printf("Client> %s\n",buf);
                }else if(s == 0)
                {
                    printf("client quit...\n");
                    AddryDel(array,num,i);
                }else
                {
                    perror("read");
                }
            }
        }
    }
}
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        printf("Usage: [%s] [port]\n",argv[0]);
        return 1;
    }

    int listen_sock = StartUp(atoi(argv[1]));

    int array[MAX_FD];
  AddryInit(array,MAX_FD);
    AddryAdd(array,MAX_FD,listen_sock);

    fd_set read_set;
    FD_ZERO(&read_set);

    struct timeval timeout = {5,0};
    for(;;)
    {
        int max = ReadFdSet(listen_sock,array, MAX_FD, &read_set);
        switch(select(max+1,&read_set,NULL,NULL,&timeout))
        {
        case 0:
            sleep(2);
            printf("select timeout...\n");
            break;
        case -1:
            perror("select");
            break;
        default:
            Service(listen_sock,&read_set,array,MAX_FD);
            break;
        }
    FD_ZERO(&read_set);
    }
}

poll服务器

#include <stdio.h>                                                                                                                      
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <sys/socket.h>

//将poll_fd结构体存储到一个数组中
#define MAX_FD 1024  //需要进行等待的文件描述符数组最大值
#define INIT -1                  //文件描述符数组初始化值
//poll_fd数组初始化
void Init(struct pollfd* fd_list, int num )
{
    int i = 0;
    for(; i < num; ++i)
    {   
        fd_list[i].fd = INIT;
        fd_list[i].events = 0;
        fd_list[i].revents = 0;
    }   
}
//往文件描述符数组中添加新的需要等待的文件描述符
void Add(struct pollfd* fd_list, int num ,int fd) 
{
    int i = 0;
    for(; i < num; ++i)
    {   
        if(fd_list[i].fd == INIT)
        {   
            fd_list[i].fd = fd; 
            fd_list[i].events = POLLIN;
            return;
        }   
    }
}
//绑定端口号，将套接字设置为监听状态
int StartUp(int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = INADDR_ANY;
    socklen_t len = sizeof(local);
    if(bind(sock,(struct sockaddr*)&local, len) < 0)
    {
        perror("bind");
        exit(2);
    }
    if(listen(sock,5) < 0)
    {
        perror("listen");
        exit(3);
    }

    return sock;
}
//服务函数
void Service(int listen_sock,struct pollfd* fd_list,int num)                                                                            
{
    int i = 0;
    for(; i < num ; ++i)
   {
        if(fd_list[i].fd != INIT && fd_list[i].revents & POLLIN )//对应的文件描述符上的读事件就绪
        {
            if(fd_list[i].fd == listen_sock)
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int client_sock = accept(listen_sock,(struct sockaddr*)&client, &len);
                if(client_sock < 0)
                {
                    perror("accept");
                    continue;
                }
                Add(fd_list,MAX_FD,client_sock);
            }
            else
            {
                char buf[1024];
                ssize_t s = read(fd_list[i].fd, buf, sizeof(buf)-1);
                if(s > 0)
                {
                    buf[s] = 0;
                    printf("Client> %s\n",buf);
                }else if(s == 0)
                {
                    printf("client quit...\n");
                    close(fd_list[i].fd);
                    fd_list[i].fd = INIT;
                }else
                {
                    perror("read");
                }                                                                                                                       
            }
        }
    }
}
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        printf("Usage: [%s] [port]\n",argv[0]);
        return 1;
    }

    int listen_sock = StartUp(atoi(argv[1]));

    struct pollfd fd_list[MAX_FD];
    Init(fd_list,MAX_FD);
    Add(fd_list,MAX_FD,listen_sock);

    for(;;)
    {
        switch(poll(fd_list,MAX_FD,1000))
        {
        case 0:
            sleep(2);
            printf("select timeout...\n");
            break;
        case -1:
            perror("select");
            break;
        default:
            Service(listen_sock,fd_list,MAX_FD);
            break;
        }
    }
}

epoll服务器(LT模式)

ET模式的epoll服务器还没写，等写完了再放上来。。。

#include <stdio.h>                                                                                                                      
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <string.h>
#define MAXEVENTS 10

//打印提示手册
void Usage()
{
    printf("Usage: ./epoll_server.c [port]\n");
    exit(0);
}

//创建监听套接字
int StartUp(int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0); 
    if(sock < 0)
    {   
        perror("socket");
        exit(1);
    }   

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(port);

    if(bind(sock,(struct sockaddr*)&server, sizeof(server)) < 0)
    {   
        perror("bind");
        exit(2);
    }

    if(listen(sock,5) < 0)
    {
        perror("listen");
        exit(3);
    }
    return sock;
}
//服务函数
void Server(int listen_sock, int epoll_fd, struct epoll_event re_epoll_event[], int num)
{
    int i = 0;
    for(;i < num;++i)
    {
        if(re_epoll_event[i].events & EPOLLIN){
            if(re_epoll_event[i].data.fd == listen_sock && re_epoll_event[i].events & EPOLLIN)
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int client_sock = accept(re_epoll_event[i].data.fd,(struct sockaddr*)&client,&len);
                if(client_sock < 0)
                {
                    perror("accept");
                    continue;
                }
                printf("Client[%s] accept success!\n",inet_ntoa(client.sin_addr));
                struct epoll_event event;
                event.data.fd = client_sock;
                event.events = EPOLLIN | EPOLLOUT;                                                                                      
                epoll_ctl(epoll_fd,EPOLL_CTL_ADD,client_sock,&event);
                continue;
            }
            else
            {
                char buf[1024];
                buf[0] = '\0';
                ssize_t s = recv(re_epoll_event[i].data.fd,buf,sizeof(buf)-1,0);
                if(s > 0)
                {
                    buf[s] = '\0';
                    printf("Client> %s\n",buf);
                    send(re_epoll_event[i].data.fd,buf,strlen(buf),0);
                    continue;
                }else if(s == 0)
                {
                    printf("Client quit\n");
                    epoll_ctl(epoll_fd,EPOLL_CTL_DEL,re_epoll_event[i].data.fd,NULL);
                    close(re_epoll_event[i].data.fd);
                    continue;
                }
                else
                {
                    perror("recv");
                    continue;
                }
            }
        }
    }
}

int main(int argc, char* argv[])
{
    if(argc != 2)
        Usage();                                                                                                                        
    int listen_sock = StartUp(atoi(argv[1]));

    //创建epoll模型
    int epoll_fd = epoll_create(MAXEVENTS+1);
    if(epoll_fd == -1)
    {
        perror("epoll_create");
        return 1;
    }
    //向epoll模型中添加文件描述符并注册事件
    struct epoll_event epoll_event;
    epoll_event.events = EPOLLIN;
    epoll_event.data.fd = listen_sock;

    //接收epoll_wait返回值
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock,&epoll_event ) < 0)
    {
        perror("epoll_ctl");
        return 2;
    }
    for(;;)
    {
        struct epoll_event re_epoll_event[MAXEVENTS];
        int ret = epoll_wait(epoll_fd,re_epoll_event,MAXEVENTS,-1);
        switch(ret)
        {
        case 0:
            printf("epoll_wait timeout...\n");
            break;
        case -1:
            perror("epoll_wait");
            break;
        default:
            Server(listen_sock,epoll_fd,re_epoll_event,ret);                                                                            
            break;
        }
    }
    return 0;
}
IT_xiaoye
关注
专栏目录
linux 内核poll/select/epoll实现剖析
在思考的路上
08-14 1274
f_ops.poll和wait_queue poll/select/epoll的实现都是基于文件提供的poll方法(f_op-&gt;poll)，该方法利用poll_table提供的_qproc方法向文件内部事件掩码_key对应的的一个或多个等待队列(wait_queue_head_t)上添加包含唤醒函数(wait_queue_t.func)的节点(wait_queue_t)，并检查文件当前就绪...
网络编程---UDP协议解析以及UDP套接字编程实现
IT_xiaoye的博客
05-26 2168
认识UDP协议 　　UDP协议全称是用户数据报协议[1]，在网络中它与TCP协议一样用于处理数据包，但不同于TCP的是，UDP是一种无连接的协议。。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据包分组、组装和不能对数据包进行排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。UDP用来支持那些需要在计算机之间传输数据的网络应用。 　　简单来说，U...
利用epoll编写echo客户端/服务器
04-22
epoll是Linux内核为处理大批量文件描述符而作了改进的epoll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。
高并发网络编程之epoll详解
freedom8531的专栏
09-11 4827
http://www.cricode.com/3499.html
epoll编程实例客户端_0729------Linux网络编程----------使用 select 、poll 和 epoll 模型 编写客户端程序...
weixin_39611937的博客
12-21 157
1.select 模型1.1 select 函数原型如下，其中 nfds 表示的描述符的最大值加1(因为这里是左闭右开区间)，中间三个参数分别表示要监听的不同类型描述符的集合，timeout用来表示轮询的时间间隔，这里用NULL表示无限等待。1.2使用 select函数编写客户端程序的一般步骤：a)初始化参数，包括初始化监听集合read_set并添加fd,以及初始化监听的最大描述符 maxfd 和...
Linux网络编程4--poll和epoll
qq_41597303的博客
11-19 276
Linux网络编程中的epoll和poll的函数说明与代码编写
linux 多线程 select,Linux多线程编程----IO【select、poll、epoll】
weixin_42516387的博客
05-06 425
IO操作多 速度就下降IO数据的 读和写IO的完成 必须等到 读事件(如磁盘 拷贝 每次要从磁盘查找数据) 和 写事件 (允许写 如写太快 写满就要马上阻塞)的就绪IO是否高效 ：主要看一次IO中 等的时间的比例的多少 (等的时间比例越少 越高效)就像钓鱼分两步：1 等 2 钓 (评价钓鱼技术高效 是 等的时间少 钓的次数多)5中IO模型1 阻塞式IO： 等的时候自己等 ， 数据搬...
网络编程--高并发服务器
最新发布
qq_74098099的博客
03-15 530
我们从客户端连接上服务端，可以进行正常的运行，但是如果此时第二个客户端也连接上服务端的话，第二个客户端是无法正常运行的，因为目前我们只能处理单进程，一对一的服务提供，无法进行多个客户端同时连接，所以，就有了高并发服务器。现在我们有了服务端和客户端（上图均以终端代替）
Linux高级IO ------ poll ，epoll(重要)
向未来❀去探索 的博客
08-22 1824
Linux高级IO ------ poll ，epoll(重要)
Help-to-understand-select-poll-epoll.rar_Help!_epoll_kernel sele
09-24
在Linux系统编程中，I/O模型的选择对于高性能服务器和复杂应用的开发至关重要。...通过阅读“Help to understand select, poll, epoll.pdf”，开发者将能够深入了解这些机制的细节，更好地适应各种复杂的系统编程挑战。
linux网络编程基础，包括tcp/upd，select/poll/epoll
11-20
在Linux系统中，网络编程是实现跨机器通信的关键技术，主要涉及TCP（传输控制协议）和UDP（用户数据报协议）这两种传输层协议，以及I/O多路复用技术如select、poll和epoll。这些知识点是每一个资深的Linux程序员必须...
网络编程-linux百度网盘
01-27
此外，多路复用技术如select、poll和epoll可以实现高并发处理，提高服务器性能。 在实际的网络编程中，TCP和UDP是两种常见的传输协议。TCP（Transmission Control Protocol）提供面向连接的服务，确保数据的可靠...
高性能网络编程 - select、 poll 、epoll 、libevent
小工匠
11-08 4222
Select（选择）：Select 是一种传统的 I/O 多路复用机制，用于在类 Unix 操作系统（如 Linux）中同时管理多个文件描述符（如网络套接字或文件）。它允许程序监视多个 I/O 源以检测可读性或可写性，并在数据可读或可写时触发事件。Select 相对简单，但在处理大量文件描述符时性能和可扩展性有限。int main()// 1.创建套接字exit(0);// 2. 绑定 ip, portexit(0);// 3. 监听exit(0);
网络编程--IO多路复用之select,poll和epoll详解
IT_xiaoye的博客
06-16 2269
什么是socket？什么是I/O操作？ 我们都知道unix(Linux)世界里，一切皆文件，而文件是什么呢？文件就是一串二进制流而已，不管socket,还是FIFO、管道、终端，对我们来说，一切都是文件，一切都是流。在信息 交换的过程中，我们都是对这些流进行数据的收发操作，简称为I/O操作(input and output)，往流中读出数据，系统调用read，写入数据，系统调用write。不过话...
网络编程---TCP/UDP套接字编程原理
IT_xiaoye的博客
05-24 1985
本篇介绍的是Linux下的网络编程，故有些接口是不适用于Windows的，但是具体概念和实现方法是大体一致的 介绍 网络编程套接字(socket)也是进程间通信的一种方式，但是不同于管道，消息队列，共享内存的是socket不仅可以实现本机内不同进程间的通信，也可以实现网络中两台不同主机间的进程通信。 socket相当于是一个文件描述符，我们将数据写入socket中，再发到目标主机，目标主机接...
网络编程---多线程/多进程版TCP套接字编程
IT_xiaoye的博客
05-28 1022
TCP\IP协议我之后会放在一起进行解释，因为这块较UDP来说比较复杂，我需要分成两三篇博客来分几个部分详谈，如TCP中的三次握手，四次回收，超时重传等，IP协议的底层通信，路由，MAC帧等，都会讲到，我尽量总结点详细一点，以免遗漏。这里我就只放上TCP套接字编程的代码，接口和一些注意的点在之前的TCP/UDP套接字原理中都有讲到，看不懂的请戳这里-&amp;gt;链接 大家研究代码的时候也可以与UDP...
Linux---进程创建
IT_xiaoye的博客
05-20 630
我们在执行一个可执行文件时，操作系统便为我们创建了一个进程，而我们今天要讲的是从已创建的进程中再创建一个进程，称为当前进程的子进程。子进程有着和父进程一样的代码，数据也同样写时拷贝了一份。 要想创建一个子进程，我们就要学习 fork()/vfork()两个函数。 认识fork函数 函数原型 #include &lt;unistd.h&gt; pid_t fork(void); 返回值：子进...
Linux---Linux系统下的进程间通信详解
IT_xiaoye的博客
04-25 376
进程间通信(IPC)介绍 进程间通信的本质就是让两个毫不相关的进程看到一份共同的资源，大概意思就是实现不同进程间的传播或交换信息 进程间通信的主要方式有管道，消息队列，共享内存，信号量，Socket，Streams等，这篇博客主要详细讲解前四种通信方式。（因为后面两个还没学，嘿嘿） 一、管道 管道是UNIX中最古老的进程间通信方式 我们把从一个进程连接到另一个进程的一个数据流称为...
libevent c++高并发网络编程-c/c++
07-14
libevent的事件模型基于操作系统提供的I/O多路复用机制，如select、poll和epoll等。它可以在不同的操作系统平台上运行，并提供一致的接口和高效的事件处理机制。借助这些机制，libevent可以同时处理大量的并发连接，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值