linux网络编程

已于 2025-02-10 20:54:26 修改
阅读量894 收藏 9
点赞数 13
分类专栏： linux 杂七杂八 文章标签： linux 网络
于 2025-02-10 20:51:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41008987/article/details/145557457
版权

io多路复用(select,poll,epoll)

select 示例

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <string.h>

constexpr int PORT = 8080;
constexpr int BUFFER_SIZE = 1024;

void setup(int &sockfd) {
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("Failed to create socket");
        exit(EXIT_FAILURE);
    }

    sockaddr_in serverAddr{};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(PORT);

    if (bind(sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("Failed to bind socket");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    if (listen(sockfd, 5) < 0) {
        perror("Failed to listen on socket");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // Set non-blocking mode
    fcntl(sockfd, F_SETFL, O_NONBLOCK);
    std::cout << "Server listening on port " << PORT << std::endl;
}

int main() {
    int serverSock, maxfd;
    setup(serverSock);

    fd_set readfds;
    FD_ZERO(&readfds);

    while (true) {
        // Add server socket and standard input to the set
        FD_SET(serverSock, &readfds);
        FD_SET(STDIN_FILENO, &readfds);
        maxfd = std::max(serverSock, STDIN_FILENO);

        // Set timeout for select (2 seconds)
        timeval timeout{};
        timeout.tv_sec = 2;
        timeout.tv_usec = 0;

        int activity = select(maxfd + 1, &readfds, nullptr, nullptr, &timeout);
        if (activity < 0 && errno != EINTR) {
            perror("select error");
        } else if (activity == 0) {
            std::cout << "Timeout occurred! No activity detected.\n";
            continue;
        }

        // Check if there's activity on the server socket
        if (FD_ISSET(serverSock, &readfds)) {
            sockaddr_in clientAddr{};
            socklen_t addrLen = sizeof(clientAddr);
            int clientSock = accept(serverSock, (struct sockaddr *)&clientAddr, &addrLen);
            if (clientSock >= 0) {
                std::cout << "New connection from " << inet_ntoa(clientAddr.sin_addr) << std::endl;
                close(clientSock);
            }
        }

        // Check if there's input on stdin
        if (FD_ISSET(STDIN_FILENO, &readfds)) {
            char buffer[BUFFER_SIZE];
            ssize_t bytesRead = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
            if (bytesRead > 0) {
                buffer[bytesRead] = '\0';
                std::cout << "Received input: " << buffer << std::endl;
            }
        }
    }

    close(serverSock);
    return 0;
}
  • 优点: 跨平台
  • 缺点:
  1. 监听文件描述符多了之后，慢的一匹，每次都要遍历所有fd
  2. 文件描述符上限1024
  3. 每次调用select，都需要把文件描述符集合从用户态拷贝到内核态

poll 示例

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <vector>

using namespace std;

#define PORT 8888
#define MAX_EVENTS 1024

int main() {
    int server_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};
    vector<pollfd> fds;

    // 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 设置地址结构
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 绑定套接字
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 监听
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 初始化pollfd数组
    pollfd fd;
    fd.fd = server_fd;
    fd.events = POLLIN;
    fds.push_back(fd);

    while (true) {
        int num_events = poll(fds.data(), fds.size(), -1); // -1 为无线阻塞，0为不阻塞，其他值表示阻塞的时间
        if (num_events < 0) {
            perror("poll");
            exit(EXIT_FAILURE);
        }

        for (int i = 0; i < num_events; ++i) {
            if (fds[i].revents & POLLIN) {
                if (fds[i].fd == server_fd) {
                    // 有新的连接
                    int new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
                    if (new_socket < 0) {
                        perror("accept");
                        exit(EXIT_FAILURE);
                    }

                    // 将新连接添加到pollfd数组
                    pollfd new_fd;
                    new_fd.fd = new_socket;
                    new_fd.events = POLLIN;
                    fds.push_back(new_fd);
                } else {
                    // 有数据可读
                    int bytes_read = read(fds[i].fd, buffer, 1024);
                    if (bytes_read <= 0) {
                        // 连接关闭或出错
                        close(fds[i].fd);
                        fds.erase(fds.begin() + i);
                        --i; // 调整索引
                    } else {
                        // 处理接收到的数据
                        cout << "Client: " << buffer << endl;
                        // ...
                    }
                }
            }
        }
    }

    return 0;
}

相比于select，poll扩展了文件描述符的个数，但其还是使用遍历所有描述符的方式检查事件触发

  • 优点
  1. 没有文件描述符个数限制（但是性能瓶颈很明显）
  2. 描述符个数小的场景下，推荐用poll，不用select
  • 缺点
  1. 就是慢，还是遍历的方式，文件描述符多了比select更差
  2. 相比于epoll，没有事件信息

epoll 示例

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <cstring>
#include <vector>

#define PORT 8080
#define MAX_EVENTS 10
#define BUFFER_SIZE 1024

// 创建非阻塞 socket
int create_server_socket() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        std::cerr << "Socket creation failed!" << std::endl;
        return -1;
    }

    // 设置 socket 为非阻塞模式
    int flags = fcntl(server_fd, F_GETFL, 0);
    fcntl(server_fd, F_SETFL, flags | O_NONBLOCK);

    sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "Binding failed!" << std::endl;
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, 3) < 0) {
        std::cerr << "Listen failed!" << std::endl;
        close(server_fd);
        return -1;
    }

    return server_fd;
}

int main() {
    int server_fd = create_server_socket();
    if (server_fd == -1) {
        return 1;
    }

    // 创建 epoll 实例
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        std::cerr << "Epoll create failed!" << std::endl;
        close(server_fd);
        return 1;
    }

    // 将 server_fd 加入 epoll 监听
    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = server_fd;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event) == -1) {
        std::cerr << "Epoll_ctl failed!" << std::endl;
        close(server_fd);
        close(epoll_fd);
        return 1;
    }

    std::vector<struct epoll_event> events(MAX_EVENTS);

    while (true) {
        // 等待事件发生
        int num_events = epoll_wait(epoll_fd, events.data(), MAX_EVENTS, -1);  // 阻塞直到有事件
        if (num_events == -1) {
            std::cerr << "Epoll wait failed!" << std::endl;
            break;
        }

        // 处理所有发生的事件
        for (int i = 0; i < num_events; ++i) {
            if (events[i].data.fd == server_fd) {
                // 新的客户端连接
                sockaddr_in client_addr;
                socklen_t client_len = sizeof(client_addr);
                int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
                if (client_fd == -1) {
                    std::cerr << "Accept failed!" << std::endl;
                } else {
                    std::cout << "New client connected!" << std::endl;

                    // 设置新连接为非阻塞
                    int flags = fcntl(client_fd, F_GETFL, 0);
                    fcntl(client_fd, F_SETFL, flags | O_NONBLOCK);

                    // 将 client_fd 添加到 epoll 中
                    event.events = EPOLLIN | EPOLLET;  // 使用边缘触发
                    event.data.fd = client_fd;
                    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event) == -1) {
                        std::cerr << "Epoll_ctl failed!" << std::endl;
                        close(client_fd);
                    }
                }
            } else if (events[i].events & EPOLLIN) {
                // 客户端发送数据
                int client_fd = events[i].data.fd;
                char buffer[BUFFER_SIZE];
                ssize_t bytes_read = read(client_fd, buffer, sizeof(buffer));
                if (bytes_read > 0) {
                    std::cout << "Received data: " << std::string(buffer, bytes_read) << std::endl;
                    // 向客户端发送数据
                    write(client_fd, "Hello, client!", 14);
                } else if (bytes_read == 0) {
                    // 客户端关闭连接
                    std::cout << "Client disconnected!" << std::endl;
                    // 从 epoll 中删除 client_fd
                    if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr) == -1) {
                        std::cerr << "Failed to remove client_fd from epoll!" << std::endl;
                    }
                    close(client_fd);
                } else {
                    std::cerr << "Read error!" << std::endl;
                    close(client_fd);
                }
            }
        }
    }

    // 清理资源
    close(server_fd);
    close(epoll_fd);
    return 0;
}

  • 缺点: 个人认为, epoll在linux下, 没有缺点, 不在linux 那也没有epoll 了, 剩下的无非就是资源啥乱七八糟的

  • epoll 的性能优势来源：

  1. 事件的通知机制:

    • epoll 则采用了更高效的事件通知机制。当一个事件发生时，内核只会通知应用程序，而无需每次遍历整个文件描述符集合。epoll 通过一个基于事件回调的机制，只有在有事件发生时，才将相关的文件描述符通知给应用程序。这样，应用程序无需每次都遍历整个文件描述符集合，而只需要关心那些真正有事件的文件描述符
    • poll/select 通过传递一个文件描述符集合（fd_set）来通知哪些文件描述符发生了事件。在每次调用时，内核都必须遍历这个文件描述符集合，并检查每个描述符的状态，哪怕没有任何事件发生，这个遍历的过程是线性的，时间复杂度是 O(n)，其中 n 是文件描述符的数量

  2. 文件描述符管理

    • epoll 用了基于事件的通知机制，称为 水平触发（Level Triggered, LT 和 边缘触发（Edge Triggered, ET）。通过 epoll_ctl 将文件描述符添加到 epoll 的监听队列中，epoll 会记录文件描述符的状态，且只有在文件描述符的状态变化时，内核才会通知应用程序，避免了不必要的遍历和重复通知
    • select/poll 如果你要监听多个文件描述符，文件描述符数量上限通常是固定的（如 FD_SETSIZE），并且在添加、删除文件描述符时，每次都需要重新传递整个文件描述符集合给内核，因此，在动态增加或删除文件描述符时，会有大量的用户态到内核态的拷贝

  3. 事件通知的优化

    • epoll 提供水平触发（Level Triggered, LT） 和 边缘触发（Edge Triggered, ET）两种模式
    • select/poll 仅支持 水平触发

Signal-Driven I/O Model(信号驱动)

信号驱动I/O是通过内核发送信号（如SIGIO）来通知进程某个I/O操作已准备好，而不需要进程主动去检查文件描述符的状态。该模型通常用于异步通知I/O事件的发生，避免了轮询操作，从而减少了CPU的浪费

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <errno.h>

#define PORT 8080

int sockfd;

// 信号处理函数
void sigio_handler(int signo) {
    char buffer[1024];
    int n;

    // 读取套接字数据
    n = read(sockfd, buffer, sizeof(buffer) - 1);
    if (n < 0) {
        if (errno == EAGAIN) {
            printf("No data available\n");
        } else {
            perror("Read error");
        }
        return;
    }
    buffer[n] = '\0';  // Null terminate the string
    printf("Received data: %s\n", buffer);
}

int main() {
    struct sockaddr_in server_addr;
    struct sigaction sa;

    // 创建一个套接字
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket failed");
        exit(EXIT_FAILURE);
    }

    // 配置服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 绑定套接字到端口
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("Bind failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // 设置套接字为非阻塞模式
    if (fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0) {
        perror("fcntl failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // 设置套接字为异步I/O模式，信号SIGIO将在I/O事件发生时发送
    if (fcntl(sockfd, F_SETFL, FASYNC) < 0) {
        perror("fcntl failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // 注册SIGIO信号处理函数
    sa.sa_handler = sigio_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGIO, &sa, NULL) < 0) {
        perror("sigaction failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // 启动监听
    if (listen(sockfd, 5) < 0) {
        perror("Listen failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d...\n", PORT);

    // 服务器主循环，等待SIGIO信号
    while (1) {
        pause();  // 等待信号到达
    }

    close(sockfd);
    return 0;
}

  1. 代码中, 定义了 sigio_handler 函数，用于处理 SIGIO 信号，当I/O操作准备好时，内核会发送此信号，并触发该函数，读取数据并进行处理

  2. fcntl(sockfd, F_SETFL, O_NONBLOCK)：设置套接字为非阻塞模式
    fcntl(sockfd, F_SETFL, FASYNC)：使套接字支持异步I/O，进程可以通过信号接收I/O事件通知

  3. 通过sigaction注册处理SIGIO信号的回调函数。每当I/O事件发生时，内核会发送SIGIO信号，进程就会执行该信号处理函数

linux 网络编程
qq_39855356的博客
09-16 5256
linux系统编程-网络编程
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
Linux网络编程
gogoingad的博客
01-28 1547
Socket服务器和客户端的开发步骤：
Linux网络编程（2024超级详细、Linux）
从无到有，守正出奇。
01-05 4555
本文是作者在学习linux网络编程的时候所写的学习笔记，同时方便巩固自己学习的知识和网友们一起分享，尚若发现有什么不对的地方，欢迎指正。
Linux网络编程——UDP编程
weixin_52109967的博客
08-15 3046
UDP通信的相关函数和实际案例代码。
Linux网络编程 | UDP编程
大柳_的博客。
06-01 3088
浅谈UDP。UDP是一种不可靠的、无连接的、数据报服务。发送端应用程序每执行一次写操作，UDP 模块就将其封装成一个 UDP 数据报发送。接收端必须及时针对每一个 UDP 数据报执行读操作，否则就会丢包。并且，如果用户没有指定足够的应用程序缓冲区来读取 UDP 数据，则 UDP 数据将被截断。 因此，采用UDP协议时必须要求接收端可以一次性收取完发送端一次发送的数据，不然就会造成数据丢失。 2.客户端 3.输出结果 UDP是一种无连接的传输方式，所以可以多个客户端同时发送。 服务器端关闭立马重启，客户
Linux网络编程——TCP编程
weixin_52109967的博客
08-10 1529
TCP编程的主要函数
Linux网络编程之TCP编程
qq_54402650的博客
09-17 2670
socket网络编程 ;TCP提供面向连接的，一对一的可靠传输的协议;UDP提供不可靠，无连接的传输协议,实现TCP多进程和多线程的并发服务器，冲冲冲！
Linux网络编程学习笔记
snaking616
05-02 3386
1.学习链接 黑马程序员-Linux网络编程：https://www.bilibili.com/video/BV1iJ411S7UA 2.课程安排 视频选集 154节课 第1天 分 秒 done 第2天 分 秒 done 第3天 分 秒 done 第4天 分 秒 ...
Linux系统编程—网络编程
m0_64319028的博客
08-11 1652
Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。网络编程的核心是Socket编程，Socket是操作系统提供的用于网络通信的接口。
Linux 网络编程
08-30
Linux网络编程是Linux开发中的一个重要领域，它允许程序员编写代码来实现网络通信功能。Linux作为一款功能强大的开源操作系统，提供了丰富的网络编程接口和工具，为开发者提供了强大的支持来构建网络服务和应用。在...
Linux网络编程（第2版）随书源代码.rar
06-24
《Linux网络编程（第2版）》是一本深入探讨Linux环境下网络编程的权威书籍，它为读者揭示了网络通信的核心原理和技术。随书附带的源代码是学习和实践网络编程的重要参考资料，可以帮助读者更直观地理解书中的理论...
linux 网络编程.pdf
01-27
linux 网络编程.pdf
在 Linux 中，目录权限，mkdir -m 选项，用法
jie18894575860的博客
05-28 425
在 Linux 中，mkdir -m 选项用于在创建目录时直接指定权限模式（无需依赖默认的 umask）。默认权限：若省略 -m，目录权限由 umask 决定（通常 777 -umask）。执行权限（x）：目录需要执行权限才能进入（cd）或访问其内容。安全建议：避免随意使用 777，可能引发安全风险。第三位：其他用户（Others）权限。第一位：所有者（Owner）权限。第二位：所属组（Group）权限。八进制 符号表示 权限说明。使用 u（所有者）、
Rock9.x（Linux）安装Redis7
最新发布
{竹子}
05-31 381
设置后台运行：将daemonize no改为daemonize yes。gcc 是C语言编译器，Redis是用C语言开发的，我们需要编译它。如果没有安装gcc，那么我们手动安装。在解压目录运行命令，必须写sudo。创建存放配置文件的文件夹。解压，进入解压文件夹。
Linux | Shell脚本的基础知识
2302_81507127的博客
05-29 771
执行一条命令完毕后，系统会给出一个退出值，若成功则为0，出现错误则1~255退出状态码是一个整数，其有效范围为0~255行为良好的UNIX命令，程序和工具都会返回0作为退出码来表示成功。
Linux远程数据同步——rsync命令详解
想进步的职场菜鸟。
05-30 587
rsync是强大的远程数据同步工具，采用差异算法提升传输效率。本文详解参数用法，提供本地/远程同步示例，涵盖权限保留、进度显示等核心功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值