linux高并发网络编程开发(epoll-udp)13_gdb定位段错误,epoll相关的函数,epoll水平触发模式,边沿触发模式,边沿非阻塞模式,文件描述符突破1024,udp通信

于 2023-06-08 20:29:44 发布
阅读量251 收藏
点赞数
分类专栏： Linux 文章标签： 网络 linux udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41865866/article/details/131114132
版权

pdf详情

01 学习目标

  1. 了解poll操作函数
  2. 熟练使用epoll多路IO模型
  3. 了解epoll ET/LT触发模式
  4. 说出UDP的通信流程

02 通过gdb定位段错误的位置

在这里插入图片描述

03 epoll相关的函数介绍

三个函数:

  • 该函数生成一个epoll专用的文件描述符
    ○ int epoll_creae(int size);
  • 用于控制某个epoll文件描述符事件，可以注册、修改、删除
    ○ int epoll_ctl(int epfd, int op, int fd,struct epoll_event *event);
    ○ 参数:
     epfd: epoll_create生成的epoll专用描述符
     op:
    EPOLL_CTL_ADD – 注册
    EPOLL_CTL_MOD – 修改
    EPOLL_CTL_DEL – 删除
     fd: 关联的文件描述符
     event: 告诉内核要监听什么事件

fd:

typedef union epoll_data {
 void *ptr;
 int fd;
 uint32_t u32;
 uint64_t u64;
} epoll_data_t;

struct sockInfo
{
int fd;
struct sockaddr_in addr;
}

struct epoll_event {
 uint32_t events; 
 epoll_data_t data;
};

events:
- EPOLLIN - 读
- EPOLLOUT - 写
- EPOLLERR - 异常
  • 等待IO事件发生 - 可以设置阻塞的函数
    ○ int epoll_wait(int epfd,
    struct epoll_event* events, // 数组
    int maxevents,
    int timeout);
     对应select和poll函数
    ○ 参数:
     epfd: 要检测的句柄
     events：用于回传待处理事件的数组
     maxevents：告诉内核这个events的大小
     timeout：为超时时间
    -1: 永久阻塞
    0: 立即返回
    大于0:

在这里插入图片描述
在这里插入图片描述

04 epoll工作流程

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

05 epoll模型代码实现

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/epoll.h>


int main(int argc, const char* argv[])
{
    if(argc < 2)
    {
        printf("eg: ./a.out port\n");
        exit(1);
    }
    struct sockaddr_in serv_addr;
    socklen_t serv_len = sizeof(serv_addr);
    int port = atoi(argv[1]);

    // 创建套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 初始化服务器 sockaddr_in 
    memset(&serv_addr, 0, serv_len);
    serv_addr.sin_family = AF_INET;                   // 地址族 
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
    serv_addr.sin_port = htons(port);            // 设置端口 
    // 绑定IP和端口
    bind(lfd, (struct sockaddr*)&serv_addr, serv_len);

    // 设置同时监听的最大个数
    listen(lfd, 36);
    printf("Start accept ......\n");

    struct sockaddr_in client_addr;
    socklen_t cli_len = sizeof(client_addr);

    // 创建epoll树根节点
    int epfd = epoll_create(2000);
    // 初始化epoll树
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event all[2000];
    while(1)
    {
        // 使用epoll通知内核fd 文件IO检测
        int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);

        // 遍历all数组中的前ret个元素
        for(int i=0; i<ret; ++i)
        {
            int fd = all[i].data.fd;
            // 判断是否有新连接
            if(fd == lfd)
            {
                // 接受连接请求
                int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                if(cfd == -1)
                {
                    perror("accept error");
                    exit(1);
                }
                // 将新得到的cfd挂到树上
                struct epoll_event temp;
                temp.events = EPOLLIN;
                temp.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                
                // 打印客户端信息
                char ip[64] = {0};
                printf("New Client IP: %s, Port: %d\n",
                    inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                    ntohs(client_addr.sin_port));
                
            }
            else
            {
                // 处理已经连接的客户端发送过来的数据
                if(!all[i].events & EPOLLIN) 
                {
                    continue;
                }

                // 读数据
                char buf[1024] = {0};
                int len = recv(fd, buf, sizeof(buf), 0);
                if(len == -1)
                {
                    perror("recv error");
                    exit(1);
                }
                else if(len == 0)
                {
                    printf("client disconnected ....\n");
                    // fd从epoll树上删除
                    ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    if(ret == -1)
                    {
                        perror("epoll_ctl - del error");
                        exit(1);
                    }
                    close(fd);
                    
                }
                else
                {
                    printf(" recv buf: %s\n", buf);
                    write(fd, buf, len);
                }
            }
        }
    }

    close(lfd);
    return 0;
}

在这里插入图片描述

06 epoll三种工作模式_epoll水平触发模式

水平触发模式 - 根据读来解释
○ 只要fd对应的缓冲区有数据
○ epoll_wait返回
○ 返回的次数与发送数据的次数没有关系
○ epoll默认的工作模式
在这里插入图片描述

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/epoll.h>


int main(int argc, const char* argv[])
{
    if(argc < 2)
    {
        printf("eg: ./a.out port\n");
        exit(1);
    }
    struct sockaddr_in serv_addr;
    socklen_t serv_len = sizeof(serv_addr);
    int port = atoi(argv[1]);

    // 创建套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 初始化服务器 sockaddr_in 
    memset(&serv_addr, 0, serv_len);
    serv_addr.sin_family = AF_INET;                   // 地址族 
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
    serv_addr.sin_port = htons(port);            // 设置端口 
    // 绑定IP和端口
    bind(lfd, (struct sockaddr*)&serv_addr, serv_len);

    // 设置同时监听的最大个数
    listen(lfd, 36);
    printf("Start accept ......\n");

    struct sockaddr_in client_addr;
    socklen_t cli_len = sizeof(client_addr);

    // 创建epoll树根节点
    int epfd = epoll_create(2000);
    // 初始化epoll树
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event all[2000];
    while(1)
    {
        // 使用epoll通知内核fd 文件IO检测
        int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
        printf("================== epoll_wait =============\n");

        // 遍历all数组中的前ret个元素
        for(int i=0; i<ret; ++i)
        {
            int fd = all[i].data.fd;
            // 判断是否有新连接
            if(fd == lfd)
            {
                // 接受连接请求
                int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                if(cfd == -1)
                {
                    perror("accept error");
                    exit(1);
                }
                // 将新得到的cfd挂到树上
                struct epoll_event temp;
                temp.events = EPOLLIN;
                temp.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                
                // 打印客户端信息
                char ip[64] = {0};
                printf("New Client IP: %s, Port: %d\n",
                    inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                    ntohs(client_addr.sin_port));
                
            }
            else
            {
                // 处理已经连接的客户端发送过来的数据
                if(!all[i].events & EPOLLIN) 
                {
                    continue;
                }

                // 读数据
                char buf[5] = {0};
                int len = recv(fd, buf, sizeof(buf), 0);
                if(len == -1)
                {
                    perror("recv error");
                    exit(1);
                }
                else if(len == 0)
                {
                    printf("client disconnected ....\n");
                    // fd从epoll树上删除
                    ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    if(ret == -1)
                    {
                        perror("epoll_ctl - del error");
                        exit(1);
                    }
                    close(fd);
                    
                }
                else
                {
                    // printf(" recv buf: %s\n", buf);
                    write(STDOUT_FILENO, buf, len);
                    write(fd, buf, len);
                }
            }
        }
    }

    close(lfd);
    return 0;
}

在这里插入图片描述

07 epoll三种工作模式_边沿触发模式

epoll_wait 调用次数越多, 系统的开销越大

边沿触发模式 - ET
○ fd - 默认阻塞属性
○ 客户端给server发数据
发一次数据server 的 epoll_wait返回一次
 不在乎数据是否读完
 如果读不完, 如何全部读出来?
while(recv());
 数据读完之后recv会阻塞
 解决阻塞问题
◊ 设置非阻塞 - fd

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/epoll.h>


int main(int argc, const char* argv[])
{
    if(argc < 2)
    {
        printf("eg: ./a.out port\n");
        exit(1);
    }
    struct sockaddr_in serv_addr;
    socklen_t serv_len = sizeof(serv_addr);
    int port = atoi(argv[1]);

    // 创建套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 初始化服务器 sockaddr_in 
    memset(&serv_addr, 0, serv_len);
    serv_addr.sin_family = AF_INET;                   // 地址族 
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
    serv_addr.sin_port = htons(port);            // 设置端口 
    // 绑定IP和端口
    bind(lfd, (struct sockaddr*)&serv_addr, serv_len);

    // 设置同时监听的最大个数
    listen(lfd, 36);
    printf("Start accept ......\n");

    struct sockaddr_in client_addr;
    socklen_t cli_len = sizeof(client_addr);

    // 创建epoll树根节点
    int epfd = epoll_create(2000);
    // 初始化epoll树
    struct epoll_event ev;

    // 设置边沿触发
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event all[2000];
    while(1)
    {
        // 使用epoll通知内核fd 文件IO检测
        int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
        printf("================== epoll_wait =============\n");

        // 遍历all数组中的前ret个元素
        for(int i=0; i<ret; ++i)
        {
            int fd = all[i].data.fd;
            // 判断是否有新连接
            if(fd == lfd)
            {
                // 接受连接请求
                int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                if(cfd == -1)
                {
                    perror("accept error");
                    exit(1);
                }
                // 将新得到的cfd挂到树上
                struct epoll_event temp;
                // 设置边沿触发
                temp.events = EPOLLIN | EPOLLET;
                temp.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                
                // 打印客户端信息
                char ip[64] = {0};
                printf("New Client IP: %s, Port: %d\n",
                    inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                    ntohs(client_addr.sin_port));
                
            }
            else
            {
                // 处理已经连接的客户端发送过来的数据
                if(!all[i].events & EPOLLIN) 
                {
                    continue;
                }

                // 读数据
                char buf[5] = {0};
                int len = recv(fd, buf, sizeof(buf), 0);
                if(len == -1)
                {
                    perror("recv error");
                    exit(1);
                }
                else if(len == 0)
                {
                    printf("client disconnected ....\n");
                    // fd从epoll树上删除
                    ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    if(ret == -1)
                    {
                        perror("epoll_ctl - del error");
                        exit(1);
                    }
                    close(fd);
                    
                }
                else
                {
                    // printf(" recv buf: %s\n", buf);
                    write(STDOUT_FILENO, buf, len);
                    write(fd, buf, len);
                }
            }
        }
    }

    close(lfd);
    return 0;
}

08 epoll三种工作模式_边沿非阻塞模式

边沿非阻塞触发
○ 效率最高
○ 如何设置非阻塞
open()
□ 设置flags
□ 必须 O_WDRW | O_NONBLOCK
□ 终端文件: /dev/tty
fcntl
□ int flag = fcntl(fd, F_GETFL);
□ flag |= O_NONBLOCK;
□ fcntl(fd, F_SETFL, flag);
○ 将缓冲区的全部数据都读出
while(recv() > 0)
{
printf():
}
当缓冲区数据读完之后, 返回是否为0?

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>

int main(int argc, const char* argv[])
{
    if(argc < 2)
    {
        printf("eg: ./a.out port\n");
        exit(1);
    }
    struct sockaddr_in serv_addr;
    socklen_t serv_len = sizeof(serv_addr);
    int port = atoi(argv[1]);

    // 创建套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 初始化服务器 sockaddr_in 
    memset(&serv_addr, 0, serv_len);
    serv_addr.sin_family = AF_INET;                   // 地址族 
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
    serv_addr.sin_port = htons(port);            // 设置端口 
    // 绑定IP和端口
    bind(lfd, (struct sockaddr*)&serv_addr, serv_len);

    // 设置同时监听的最大个数
    listen(lfd, 36);
    printf("Start accept ......\n");

    struct sockaddr_in client_addr;
    socklen_t cli_len = sizeof(client_addr);

    // 创建epoll树根节点
    int epfd = epoll_create(2000);
    // 初始化epoll树
    struct epoll_event ev;

    // 设置边沿触发
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event all[2000];
    while(1)
    {
        // 使用epoll通知内核fd 文件IO检测
        int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
        printf("================== epoll_wait =============\n");

        // 遍历all数组中的前ret个元素
        for(int i=0; i<ret; ++i)
        {
            int fd = all[i].data.fd;
            // 判断是否有新连接
            if(fd == lfd)
            {
                // 接受连接请求
                int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                if(cfd == -1)
                {
                    perror("accept error");
                    exit(1);
                }
                // 设置文件cfd为非阻塞模式
                int flag = fcntl(cfd, F_GETFL);
                flag |= O_NONBLOCK;
                fcntl(cfd, F_SETFL, flag);

                // 将新得到的cfd挂到树上
                struct epoll_event temp;
                // 设置边沿触发
                temp.events = EPOLLIN | EPOLLET;
                temp.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                
                // 打印客户端信息
                char ip[64] = {0};
                printf("New Client IP: %s, Port: %d\n",
                    inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                    ntohs(client_addr.sin_port));
                
            }
            else
            {
                // 处理已经连接的客户端发送过来的数据
                if(!all[i].events & EPOLLIN) 
                {
                    continue;
                }

                // 读数据
                char buf[5] = {0};
                int len;
                // 循环读数据
                while( (len = recv(fd, buf, sizeof(buf), 0)) > 0 )
                {
                    // 数据打印到终端
                    write(STDOUT_FILENO, buf, len);
                    // 发送给客户端
                    send(fd, buf, len, 0);
                }
                if(len == 0)
                {
                    printf("客户端断开了连接\n");
                    ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    if(ret == -1)
                    {
                        perror("epoll_ctl - del error");
                        exit(1);
                    }
                    close(fd);
                }
                else if(len == -1)
                {
                    if(errno == EAGAIN)
                    {
                        printf("缓冲区数据已经读完\n");
                    }
                    else
                    {
                        printf("recv error----\n");
                        exit(1);
                    }
                }
#if 0
                if(len == -1)
                {
                    perror("recv error");
                    exit(1);
                }
                else if(len == 0)
                {
                    printf("client disconnected ....\n");
                    // fd从epoll树上删除
                    ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    if(ret == -1)
                    {
                        perror("epoll_ctl - del error");
                        exit(1);
                    }
                    close(fd);
                    
                }
                else
                {
                    // printf(" recv buf: %s\n", buf);
                    write(STDOUT_FILENO, buf, len);
                    write(fd, buf, len);
                }
#endif
            }
        }
    }

    close(lfd);
    return 0;
}

在这里插入图片描述

09 文件描述符突破1024

  1. select - 突破不了, 需要编译内核
    a. 通过数组实现的
  2. poll和epoll可以突破1024限制
    ○ poll内部链表
    ○ epoll红黑树

1.查看受计算机硬件限制的文件描述符上限
○ cat/vi /proc/sys/fs/file-max
2. 通过配置文件修改上限值
○ /etc/security/limits.conf

*   soft    nofile      8000 
*   hard nofile 8000

重启或注销虚拟机

10 udp通信流程

1.tcp-面向连接的安全的数据包通信
a.基于流sock_stream
2.udp-面向无连接不安全报文传输
3.通信流程
○服务器端:
(1）创建套接字-socket
第二个参数:SOCK_DGRAM
(2) 绑定IP和端口: bind
□fd
□structsockaddr --服务器
(3) 通信
接收数据:recvfrom

ssize_t recvfrom(int sockfd, void 
*buf, size_t len, int flags,struct 
sockaddr *src_addr,socklen_t 
*addrlen);-同accept的2,3个参数使用方法相同

fd-文件描述符
buf:接收数据缓冲区len:buf的最大容量
flags:0
src_addr:另一端的IP和端口,传出参数
addrlen:传入传出参数

发送数据: sendto

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);

sockfd: socket函数创建出来的
buf:存储发送的数据
len:发送的数据的长度
flags:0
dest_addr:另一端的IP和端口
addrlen:dest_addr长度

udp服务器端:需要一个套接字, 通信

○客户端:
（1）创建一个用于通信的套接字:socket
（2）通信
□发送数据:sendto
需要先准备好一个结构体:struct sockaddr_in
◊存储服务器的IP和端口
□接收数据:recvform
○udp的数据是不安全的,容易丢包
丢包,丢全部还一部分?□只能丢全部
优点:效率高

在这里插入图片描述

11 udp服务器端代码实现

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <arpa/inet.h>

int main(int argc, const char* argv[])
{
    // 创建套接字
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket error");
        exit(1);
    }
    
    // fd绑定本地的IP和端口
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8765);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    int ret = bind(fd, (struct sockaddr*)&serv, sizeof(serv));
    if(ret == -1)
    {
        perror("bind error");
        exit(1);
    }

    struct sockaddr_in client;
    socklen_t cli_len = sizeof(client);
    // 通信
    char buf[1024] = {0};
    while(1)
    {
        int recvlen = recvfrom(fd, buf, sizeof(buf), 0, 
                               (struct sockaddr*)&client, &cli_len);
        if(recvlen == -1)
        {
            perror("recvform error");
            exit(1);
        }
        
        printf("recv buf: %s\n", buf);
        char ip[64] = {0};
        printf("New Client IP: %s, Port: %d\n",
            inet_ntop(AF_INET, &client.sin_addr.s_addr, ip, sizeof(ip)),
            ntohs(client.sin_port));

        // 给客户端发送数据
        sendto(fd, buf, strlen(buf)+1, 0, (struct sockaddr*)&client, sizeof(client));
    }
    
    close(fd);

    return 0;
}

12 udp客户端代码实现

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <arpa/inet.h>

int main(int argc, const char* argv[])
{
    // create socket
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket error");
        exit(1);
    }

    // 初始化服务器的IP和端口
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8765);
    inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);

    // 通信
    while(1)
    {
        char buf[1024] = {0};
        fgets(buf, sizeof(buf), stdin);
        // 数据的发送 - server - IP port
        sendto(fd, buf, strlen(buf)+1, 0, (struct sockaddr*)&serv, sizeof(serv));

        // 等待服务器发送数据过来
        recvfrom(fd, buf, sizeof(buf), 0, NULL, NULL);
        printf("recv buf: %s\n", buf);
    }
    
    close(fd);

    return 0;
}

在这里插入图片描述

好奇养活小猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
epoll实现tcp百万级高并发测试
u014220105的博客
12-06 3918
**epoll实现高并发测试** 1,准备环境 Server 端： 系统端口限制 默认查看：cat /proc/sys/net/ipv4/ip_local_port_range 32768 60999（在/etc/sysctl.conf修改） 最大文件句柄限制：查看：cat /proc/sys/fs/file-nr 297440 0 297373（最大值系统计算） 备注：这里最大...
Linux高并发网络编程开发——epoll-udp
Alliswell_WP
07-08 1281
在学习Linux高并发网络编程开发总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-Linux系统编程-第13天（epoll-udp） 目录：一、学习目标二、复习1、通过gdb定位段错误的位置2、TCP状态转换复习三、epoll1、epoll相关的函数介绍和工作流程2、epoll模型伪代码3、epoll模型代码实现4、epoll三种工作模式5...
linux 网络编程 2019.1.13 （epoll，epoll的三种触发方式，UDP通信，tcp和udp的使用场景）
一直走，不要回头
01-14 2854
学习目标 了解poll操作函数 熟练使用epoll多路IO模型 了解epoll ET/LT触发模式 说出UDP的通信流程     一些零散的操作   gdb设置参数   vim中查找某个词   段错误出现的原因 你访问了不改访问的内存 你访问的内存，你没权限 你操作的内存根本就不存在       epoll   三个函数   1、该函数生成一个e...
epoll_udp服务器
06-18
在linux下通过epoll实现udp服务器的同时收发工作
如果这篇文章说不清epoll的本质，那就过来掐死我吧！
技术大白的博客
06-06 79
然后调用select，如果fds中的所有socket都没有数据，select会阻塞，直到有一个socket接收到数据，select返回，唤醒进程。此处的中断程序主要有两项功能，先将网络数据写入到对应socket的接收缓冲区里面（步骤④），再唤醒进程A（步骤⑤），重新将进程A放入工作队列中。中断的过程如下图，和函数调用差不多。如下的代码中，先用epoll_create创建一个epoll对象epfd，再通过epoll_ctl将需要监视的socket添加到epfd中，最后调用epoll_wait等待数据。
linux epoll socket UDP通信的实现! 看清楚不是tcp哟.zip
01-19
linux epoll socket UDP通信的实现! 看清楚不是tcp哟.zip
Linux网络编程基础5（epoll，epoll三种工作模式，UDP通信流程，TCP和UDP的使用场景）
kuanyew的博客
07-16 713
Linux网络编程基础5（epoll，epoll三种工作模式，UDP通信流程）1. epoll1.1 相关函数1.1.1 epoll_creae1.1.2 epoll_ctl1.1.3 epoll_wait1.2 epoll比select和poll效率高的原因1.3 epoll注意事项1.4 epoll工作流程伪代码1.5 epoll应用实例完整代码1.6 epoll应用实例22. epoll的三种工作模式2.1 水平触发模式（默认工作模式）2.2 边沿触发模式——ET（是阻塞的）2.3 边沿非阻塞触发——
四、网络编程epoll-udp003
Tlwhisper的博客
03-20 448
复习： 之前的多进程、多线程实现多个连接请求的时候，程序员既要管理监听，又要管理通信。 select委托内核去做客服端连接请求的监听，程序员专注于通信， 需要给内核一些数据：就是select参数，sizeof得出的单位是字节 循环委托内核做监听检测 4、epoll gdb 调试 gcc test.c -g -lpthread gdb ./a.out 进入gdb调试界面： set args 9898 // 设置出入参数 r quit 1、3个函数 int epoll_create( int size); 此
Linux-net-Programming-User-Guide.rar_实用linux编程教程
09-21
《Linux网络编程用户指南》是一本专为初学者和有一定经验的开发者设计的教程，它深入浅出地讲解了在Linux环境下进行网络编程的核心概念和技术。这本书覆盖了从基础的网络概念到高级的网络编程技巧，是理解并掌握...
icp-native.rar_Linux/Unix编程_Unix_Linux_
08-11
标题中的"icp-native.rar_Linux/Unix编程_Unix_Linux_"表明这是一份与Linux/Unix系统编程相关的资源，可能包含源代码或文档，主要关注的是“icp-native”和“bc_xprt”这两个部分。描述中的"Functions to create and...
采用epoll模型设计多路udp接收程序
03-08
使用方法，在命令行下输入 ./RecvRtpAndSave 8000 16 其中8000是基础udp接收端口，16是接收16路流
linux高性能服务器编程.zip_Linux/Unix编程_C/C++__Linux/Unix编程_C/C++_
08-09
在Linux/Unix环境中进行高性能服务器编程，C/C++语言是常用的选择，因为它们提供了底层的系统访问能力，能够实现高效且灵活的网络通信。本资料集合包含了一本关于Linux高性能服务器编程的书籍的所有源代码，旨在帮助...
linux网络编程-源代码.rar
03-02
《Linux网络编程》一书是IT领域中关于操作系统与网络通信的经典教材，它深入探讨了在Linux环境下如何进行网络编程，涵盖了从低级socket接口到高级应用层协议的实现。这个压缩包“linux网络编程-源代码.rar”包含了该...
epoll+socket实现 socket并发 linux服务器
神棍之路
12-28 645
/* 实现功能：通过epoll, 处理多个socket * 监听一个端口,监听到有链接时,添加到epoll_event * xs */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;sys/socket.h&gt; #include &lt;poll.h&...
Linux系统下基于IO多路复用的大规模可靠UDP服务器的实现（二）
08-05 520
六、用户态实现 通过上篇文章，我们可知在用户态实现IO多路复用的大规模可靠UDP服务器不能用原生的udp协议，否则会面临当链接数增加的时候CPU和内存占用都增加很快直至承受不住的情况。要规避内核的种种弊端，就必须要用用户态协议栈来实现，这也是最适合最顺理成章的方案。我们可以站在前人的肩膀上，让我们来看一下DPDP+MTCP架构。 1.dpdk+mtcp dpdk在驱动层工作，前文有所介绍。mtcp在tcp协议层工作，不仅实现了mtcp_socket、mtcp_bind、...
Linux简单高并发模型——Epoll + 线程池
波波诸葛伟
10-08 1065
https://blog.csdn.net/qq_25425023/article/details/70199133
14-广播-组播-本地套接字.pdf
最新发布
07-02
总体而言，本文详细介绍了使用epoll实现事件驱动网络编程的方法，包括epoll_create()、epoll_ctl()和epoll_wait()等函数的使用，以及设置事件类型和触发模式的方式。同时，还介绍了非阻塞模式、数据接收和客户端断开...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值