linux下I/O模型并发的epoll多进程池协程实现

已于 2024-06-23 20:53:07 修改
阅读量382 收藏 1
点赞数 4
分类专栏： linux C++ 文章标签： 算法 linux IO多路复用 协程 c++
于 2024-06-23 18:43:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vbgesab/article/details/139904243
版权
linux 同时被 2 个专栏收录
5 篇文章 0 订阅
订阅专栏
C++
3 篇文章 0 订阅
订阅专栏

方法1

主要思路：

  1. 定义了一个EventData结构体，用于存储事件相关的数据，如文件描述符、epoll 文件描述符、协程 ID 等。
  2. EchoDeal函数用于处理请求消息，并生成响应消息。
  3. handlerClient函数是协程的执行函数，用于处理客户端连接。它通过循环读取数据、解析请求、执行业务处理、发送响应等步骤，实现了对客户端请求的处理。
  4. handler函数是主函数，用于创建监听套接字、初始化 epoll、设置非阻塞模式、添加读事件等操作。然后进入一个循环，通过 epoll_wait 等待事件发生，并根据事件类型进行相应的处理，如接受新连接、处理客户端请求等。
  5. 在主函数中，通过 fork 创建多个子进程，每个子进程都执行handler函数，从而实现多进程并发处理。

示例代码： 

#include <arpa/inet.h>  // 包含网络地址转换相关的头文件
#include <assert.h>  // 包含断言相关的头文件
#include <fcntl.h>  // 包含文件控制相关的头文件
#include <netinet/in.h>  // 包含网络协议相关的头文件
#include <stdio.h>  // 包含标准输入输出相关的头文件
#include <stdlib.h>  // 包含标准库相关的头文件
#include <sys/epoll.h>  // 包含 epoll 相关的头文件
#include <sys/socket.h>  // 包含套接字相关的头文件
#include <unistd.h>  // 包含 Unix 标准相关的头文件

#include <iostream>  // 包含 C++ 的输入输出流头文件

#include "../coroutine.h"  // 包含自定义的协程相关头文件
#include "../epollctl.hpp"  // 包含自定义的 epoll 控制相关头文件

// 定义 EventData 结构体，用于存储事件相关的数据
struct EventData {  
    EventData(int fd, int epoll_fd) : fd_(fd), epoll_fd_(epoll_fd){};  // 构造函数，初始化成员变量
    int fd_{0};  // 文件描述符
    int epoll_fd_{0};  // epoll 文件描述符
    int cid_{MyCoroutine::INVALID_ROUTINE_ID};  // 协程 ID
    MyCoroutine::Schedule *schedule_{nullptr};  // 协程调度器指针
};  // 结构体定义结束

// EchoDeal 函数，用于处理请求消息，并生成响应消息
void EchoDeal(const std::string reqMessage, std::string &respMessage) { respMessage = reqMessage; }  // 函数定义结束

// handlerClient 函数，协程的执行函数，用于处理客户端连接
void handlerClient(void *arg) {  
    EventData *eventData = (EventData *)arg;  // 将传入的 void* 指针转换为 EventData* 指针
    auto releaseConn = [&eventData]() {  // 定义一个匿名函数用于释放连接资源
        EchoServer::ClearEvent(eventData->epoll_fd_, eventData->fd_);  // 清除事件
        delete eventData;  // 释放内存
    };
    ssize_t ret = 0;  // 用于存储读取或写入的返回值
    EchoServer::Codec codec;  // 编解码器对象
    std::string reqMessage;  // 请求消息字符串
    std::string respMessage;  // 响应消息字符串
    while (true) {  // 读操作循环
        uint8_t data[100];  // 数据缓冲区
        ret = read(eventData->fd_, data, 100);  // 尝试从文件描述符读取数据
        if (ret == 0) {  // 对端关闭连接
            perror("peer close connection");  // 打印错误信息
            releaseConn();  // 释放连接资源
            return;  // 函数返回
        }
        if (ret < 0) {  // 读取错误
            if (EINTR == errno) continue;  // 被中断，继续尝试读取
            if (EAGAIN == errno or EWOULDBLOCK == errno) {  // 无数据可读
                MyCoroutine::CoroutineYield(*eventData->schedule_);  // 让出 CPU
                continue;  // 继续下一次循环
            }
            perror("read failed");  // 打印读取失败的错误信息
            releaseConn();  // 释放连接资源
            return;  // 函数返回
        }
        codec.DeCode(data, ret);  // 解码读取的数据
        if (codec.GetMessage(reqMessage)) {  // 从解码数据中获取完整的请求消息
            break;  // 跳出读循环
        }
    }
    // 执行到这里说明已经读取到一个完整的请求
    EchoDeal(reqMessage, respMessage);  // 调用处理函数生成响应
    EchoServer::Packet pkt;  // 数据包对象
    codec.EnCode(respMessage, pkt);  // 对响应进行编码
    EchoServer::ModToWriteEvent(eventData->epoll_fd_, eventData->fd_, eventData);  // 切换为监听可写事件
    ssize_t sendLen = 0;  // 已发送数据的长度
    while (sendLen!= pkt.Len()) {  // 写操作循环
        ret = write(eventData->fd_, pkt.Data() + sendLen, pkt.Len() - sendLen);  // 尝试写入数据
        if (ret < 0) {  // 写入错误
            if (EINTR == errno) continue;  // 被中断，继续尝试写入
            if (EAGAIN == errno or EWOULDBLOCK == errno) {  // 不可写
                MyCoroutine::CoroutineYield(*eventData->schedule_);  // 让出 CPU
                continue;  // 继续下一次循环
            }
            perror("write failed");  // 打印写入失败的错误信息
            releaseConn();  // 释放连接资源
            return;  // 函数返回
        }
        sendLen += ret;  // 更新已发送数据的长度
    }
    releaseConn();  // 释放连接资源
}

// handler 函数，主函数，用于创建监听套接字、初始化 epoll、设置非阻塞模式、添加读事件等操作
void handler(char *argv[]) {  
    int sockFd = EchoServer::CreateListenSocket(argv[1], atoi(argv[2]), true);  // 创建监听套接字
    if (sockFd < 0) {  // 如果创建失败
        return;  // 函数返回
    }
    epoll_event events[2048];  // epoll 事件数组
    int epollFd = epoll_create(1024);  // 创建 epoll 实例
    if (epollFd < 0) {  // 如果创建失败
        perror("epoll_create failed");  // 打印错误信息
        return;  // 函数返回
    }
    EventData eventData(sockFd, epollFd);  // 创建事件数据对象
    EchoServer::SetNotBlock(sockFd);  // 设置套接字为非阻塞
    EchoServer::AddReadEvent(epollFd, sockFd, &eventData);  // 添加可读事件
    MyCoroutine::Schedule schedule;  // 协程调度器
    MyCoroutine::ScheduleInit(schedule, 10000);  // 初始化协程池
    int msec = -1;  // 超时时间
    while (true) {  // 无限循环
        int num = epoll_wait(epollFd, events, 2048, msec);  // 等待 epoll 事件
        if (num < 0) {  // 如果等待失败
            perror("epoll_wait failed");  // 打印错误信息
            continue;  // 继续下一次循环
        } else if (num == 0) {  // 超时无事件
            sleep(0);  // 让出 CPU
            msec = -1;  // 下次超时时间设置为 -1
            continue;  // 继续下一次循环
        }
        msec = 0;  // 下次大概率还有事件，故 msec 设置为 0
        for (int i = 0; i < num; i++) {  // 处理事件
            EventData *eventData = (EventData *)events[i].data.ptr;  // 获取事件数据指针
            if (eventData->fd_ == sockFd) {  // 是监听套接字的事件
                EchoServer::LoopAccept(sockFd, 2048, [epollFd](int clientFd) {
                    EventData *eventData = new EventData(clientFd, epollFd);  // 创建新的事件数据对象
                    EchoServer::SetNotBlock(clientFd);  // 设置套接字为非阻塞
                    EchoServer::AddReadEvent(epollFd, clientFd, eventData);  // 监听可读事件
                });
                continue;  // 继续下一次循环
            }
            if (eventData->cid_ == MyCoroutine::INVALID_ROUTINE_ID) {  // 第一次事件，则创建协程
                if (MyCoroutine::CoroutineCanCreate(schedule)) {  // 可以创建协程
                    eventData->schedule_ = &schedule;  // 设置协程调度器
                    eventData->cid_ = MyCoroutine::CoroutineCreate(schedule, handlerClient, eventData, 0);  // 创建协程
                    MyCoroutine::CoroutineResumeById(schedule, eventData->cid_);  // 唤醒刚刚创建的协程处理客户端请求
                } else {
                    std::cout << "MyCoroutine is full" << std::endl;  // 输出协程已满的信息
                }
            } else {
                MyCoroutine::CoroutineResumeById(schedule, eventData->cid_);  // 唤醒之前主动让出 cpu 的协程
            }
        }
        MyCoroutine::ScheduleTryReleaseMemory(schedule);  // 尝试释放协程内存
    }
}

// main 函数
int main(int argc, char *argv[]) {  
    if (argc!= 3) {  // 如果命令行参数数量不正确
        std::cout << "invalid input" << std::endl;  // 输出错误信息
        std::cout << "example:./EpollReactorProcessPoolCoroutine 0.0.0.0 1688" << std::endl;  // 给出正确用法示例
        return -1;  // 程序返回 -1
    }
    for (int i = 0; i < EchoServer::GetNProcs(); i++) {  // 循环创建子进程
        pid_t pid = fork();  // 创建进程
        if (pid < 0) {  // 创建失败
            perror("fork failed");  // 打印错误信息
            continue;  // 继续下一次循环
        }
        if (0 == pid) {  // 子进程
            handler(argv);  // 处理客户端请求
            exit(0);  // 子进程退出
        }
    }
    while (true) sleep(1);  // 父进程进入死循环
    return 0;  // 程序正常结束返回 0
}

方法2:

思路：

  1. main 函数首先检查命令行参数数量是否正确。
  2. 然后通过循环创建子进程。
  3. 子进程调用 handler 函数。
  4. 在 handler 函数中，创建监听套接字和 epoll 实例，设置套接字为非阻塞并添加可读事件，初始化协程调度器。
  5. 进入一个无限循环，通过 epoll_wait 等待事件发生。
  6. 根据事件的类型进行处理：
    • 如果是监听套接字的事件，处理新的连接。
    • 对于客户端连接的事件，如果是第一次事件则创建协程并唤醒，否则唤醒已有的协程。
  7. 协程中的 handlerClient 函数处理客户端的读写操作。
#include <arpa/inet.h>
#include <assert.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>

#include <iostream>

#include "../coroutine.h"
#include "../epollctl.hpp"

// 定义事件数据结构体
struct EventData {
  EventData(int fd, int epoll_fd) : fd_(fd), epoll_fd_(epoll_fd){};  // 构造函数
  int fd_{0};  // 文件描述符
  int epoll_fd_{0};  // epoll 文件描述符
  int cid_{MyCoroutine::INVALID_ROUTINE_ID};  // 协程 ID
  MyCoroutine::Schedule *schedule_{nullptr};  // 协程调度器指针
};

// 处理请求并生成响应的函数
void EchoDeal(const std::string reqMessage, std::string &respMessage) { respMessage = reqMessage; }

// 处理客户端的函数
void handlerClient(void *arg) {
  EventData *eventData = (EventData *)arg;  // 获取事件数据指针
  auto releaseConn = [&eventData]() {  // 定义释放连接的匿名函数
    EchoServer::ClearEvent(eventData->epoll_fd_, eventData->fd_);
    delete eventData;  // 释放内存
  };
  ssize_t ret = 0;  // 读取结果
  EchoServer::Codec codec;  // 编解码器对象
  std::string reqMessage;  // 请求消息
  std::string respMessage;  // 响应消息
  while (true) {  // 读操作循环
    uint8_t data[100];  // 数据缓冲区
    ret = read(eventData->fd_, data, 100);  // 尝试读取数据
    if (ret == 0) {  // 对端关闭连接
      perror("peer close connection");
      releaseConn();
      return;
    }
    if (ret < 0) {  // 读取错误
      if (EINTR == errno) continue;  // 被中断，继续尝试
      if (EAGAIN == errno or EWOULDBLOCK == errno) {  // 无数据可读
        MyCoroutine::CoroutineYield(*eventData->schedule_);  // 让出 CPU
        continue;
      }
      perror("read failed");
      releaseConn();
      return;
    }
    codec.DeCode(data, ret);  // 解码数据
    if (codec.GetMessage(reqMessage)) {  // 获取完整请求
      break;
    }
  }
  // 执行到这里说明已经读取到一个完整的请求
  EchoDeal(reqMessage, respMessage);  // 处理请求生成响应
  EchoServer::Packet pkt;
  codec.EnCode(respMessage, pkt);  // 编码响应
  EchoServer::ModToWriteEvent(eventData->epoll_fd_, eventData->fd_, eventData);  // 切换为监听可写事件
  ssize_t sendLen = 0;  // 已发送长度
  while (sendLen!= pkt.Len()) {  // 写操作循环
    ret = write(eventData->fd_, pkt.Data() + sendLen, pkt.Len() - sendLen);  // 尝试写入
    if (ret < 0) {  // 写入错误
      if (EINTR == errno) continue;  // 被中断，继续尝试
      if (EAGAIN == errno or EWOULDBLOCK == errno) {  // 不可写
        MyCoroutine::CoroutineYield(*eventData->schedule_);  // 让出 CPU
        continue;
      }
      perror("write failed");
      releaseConn();
      return;
    }
    sendLen += ret;  // 更新已发送长度
  }
  releaseConn();  // 释放连接资源
}

// 主处理函数
void handler(char *argv[]) {
  int sockFd = EchoServer::CreateListenSocket(argv[1], atoi(argv[2]), true);  // 创建监听套接字
  if (sockFd < 0) {
    return;
  }
  epoll_event events[2048];  // epoll 事件数组
  int epollFd = epoll_create(1024);  // 创建 epoll 实例
  if (epollFd < 0) {
    perror("epoll_create failed");
    return;
  }
  EventData eventData(sockFd, epollFd);  // 创建事件数据对象
  EchoServer::SetNotBlock(sockFd);  // 设置套接字为非阻塞
  EchoServer::AddReadEvent(epollFd, sockFd, &eventData);  // 添加可读事件
  MyCoroutine::Schedule schedule;  // 协程调度器
  MyCoroutine::ScheduleInit(schedule, 10000);  // 初始化协程池
  int msec = -1;  // 超时时间
  while (true) {
    int num = epoll_wait(epollFd, events, 2048, msec);  // 等待 epoll 事件
    if (num < 0) {  // 等待失败
      perror("epoll_wait failed");
      continue;
    } else if (num == 0) {  // 超时无事件
      sleep(0);  // 让出 CPU
      msec = -1;  // 下次超时时间设置为 -1
      continue;
    }
    msec = 0;  // 有事件，下次超时时间设置为 0
    for (int i = 0; i < num; i++) {  // 处理事件
      EventData *eventData = (EventData *)events[i].data.ptr;
      if (eventData->fd_ == sockFd) {  // 是监听套接字的事件
        EchoServer::LoopAccept(sockFd, 2048, [epollFd](int clientFd) {
          EventData *eventData = new EventData(clientFd, epollFd);
          EchoServer::SetNotBlock(clientFd);
          EchoServer::AddReadEvent(epollFd, clientFd, eventData);  // 处理新连接
        });
        continue;
      }
      if (eventData->cid_ == MyCoroutine::INVALID_ROUTINE_ID) {  // 第一次事件
        if (MyCoroutine::CoroutineCanCreate(schedule)) {  // 可以创建协程
          eventData->schedule_ = &schedule;
          eventData->cid_ = MyCoroutine::CoroutineCreate(schedule, handlerClient, eventData, 0);  // 创建协程
          MyCoroutine::CoroutineResumeById(schedule, eventData->cid_);  // 唤醒协程
        } else {
          std::cout << "MyCoroutine is full" << std::endl;
        }
      } else {
        MyCoroutine::CoroutineResumeById(schedule, eventData->cid_);  // 唤醒已有协程
      }
    }
    MyCoroutine::ScheduleTryReleaseMemory(schedule);  // 尝试释放协程内存
  }
}

int main(int argc, char *argv[]) {
  if (argc!= 3) {  // 检查命令行参数数量
    std::cout << "invalid input" << std::endl;
    std::cout << "example:./EpollReactorProcessPoolCoroutine 0.0.0.0 1688" << std::endl;
    return -1;
  }
  for (int i = 0; i < EchoServer::GetNProcs(); i++) {  // 循环创建子进程
    pid_t pid = fork();  // 创建进程
    if (pid < 0) {  // 创建失败
      perror("fork failed");
      continue;
    }
    if (0 == pid) {  // 子进程
      handler(argv);  // 处理客户端请求
      exit(0);
    }
  }
  while (true) sleep(1);  // 父进程进入死循环
  return 0;
}

总的来说，程序通过多进程和协程的结合，实现了对客户端连接的处理和高效的 I/O 操作。

WishYouAFortune
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文彻底搞懂I/O多路复用及其技术
Linuxhus的博客
08-31 797
前言 ​ 高性能是每个程序员的追求，无论写一行代码还是做一个系统，都希望能够达到高性能的效果。高性能架构设计主要集中在两方面： 尽量提升单服务器的性能，将单服务器的性能发挥到极致 如果单服务器无法支撑性能，设计服务器集群方案 ​ 单服务器高性能的关键之一就是服务器采取的网络编程模型。服务器如何管理连接，如何处理请求等。这两个设计点最终都和操作系统的I/O模型及进程模型相关。 I/O模型：阻塞、非阻塞、同步、异步 进程模型：单进程、多进程、多线程。 ​ 我们所说的I/O模型是指网络I/O模型,就是服
聊聊对不同I/O模型的理解 (阻塞/非阻塞IO，同步/异步IO)
Linuxhus的博客
08-20 536
一、关于I/O模型的问题 　　最近通过对ucore操作系统的学习，让我打开了操作系统内核这一黑盒子，与之前所学知识结合起来，解答了长久以来困扰我的关于I/O的一些问题。 　　1. 为什么redis能以单工作线程处理高达几万的并发请求？ 　　2. 什么是I/O多路复用？为什么redis、nginx、nodeJS以及netty等以高性能著称的服务器其底层都利用了I/O多路复用技术？ 　　3. 非阻塞I/O为什么会流行起来，在许多场景下取代了传统的阻塞I/O？ 　　4. 非阻塞I/O真的是银弹吗？为什么
go标准库I/O模型:epoll+多协程
weixin_34064653的博客
04-08 479
本文为linux环境下的总结，其他操作系统本质差别不大。本地文件I/O和网络I/O逻辑类似。 epoll+多线程的模型 epoll+多线程模型和epoll 单进程区别、优点     对比于redis这样典型的epoll+单进程为主的模型，个人理解epoll+多线程模型相对来说,epoll+多线程更利于程序员编写，维护代码，毕竟多线程的模型更符合多数人的逻辑方式。     例如，单进程下，如果是简单...
python并发编程-进程池线程池-协程-I/O模型-04
RealizeInnerSelf丶
08-15 381
目录进程池线程池的使用*****进程池/线程池的创建和提交回调验证复用池子里的线程或进程异步回调机制通过闭包给回调函数添加额外参数(扩展)协程***概念回顾(协程这里再理一下)如何实现协程生成器的yield 可以实现保存状态(行不通)gevent模块实现模块安装下载gevent基本介绍通过gevent实现遇到 IO自动切换状态(单线程下并发)在计算密集型任务中使用利用gevent在单线程...
并发模型和I/O模型介绍
Linuxhus的博客
08-02 199
协程的优势在于，相比回调的方式，写的异步代码可读性更强。无论是多进程并发，还是多线程并发，要么通过线程间互斥同步(spinlock，rwlock，mutex,condition,信号量)，要么通过进程间通信(共享内存，管道，信号量，套接字)，本质都是为了协同。这种模式下，资源利用率是上去了，但是却有很多浪费，线程数与请求数成正比，意味着频繁的创建/销毁线程开销，频繁的上下文切换开销，这些都是通过系统调用完成，需要应用态到内核态的切换，导致sys-cpu偏高，资源并没有充分利用在处理请求上。...
关于I/O与并发
kaydenlsr
09-17 701
由于笔者在之前发布的一文玩转NGINX中提到过I/O复用模型，在此另起一篇文章简述相关技术。I/O输入/输出(Input/Output)，分为IO设备和IO接口两个部分。在POSIX兼容的系统上，例如Linux系统 [1]，I/O操作可以有多种方式，比如DIO(Direct I/O)，AIO(Asynchronous I/O，异步I/O)，Memory-Mapped I/O(内存映射I/O)等，不同的I/O方式有不同的实现方式和性能，在不同的应用中可以按情况选择不同的I/O方式。
网络/Network - 网络I/O模型 - 学习/实践
william_n的博客
04-01 711
主要用于学习计算机网络中的网络I/O的各种模型，以及各自的优缺点，使用场景。
linux的进程/线程/协程系列5：协程的发展复兴与实现现状
shao918516的博客
03-05 1198
本篇从协程机制的起源、发展史及当前现状介绍协程。第一章介绍协同工作制的起源及发展，协程蛰伏的原因及协同式思想的实际应用；第二章描述协程复兴，通过高并发带来的，引出协程风行的历史机遇；第三章详解协程的两个特点：有栈/无栈、对称/非对称；第四章讲解协程的实现方式，引出Python生成器中的协程思想，最后简述当前协程库现状。
python 协程详解及I/O多路复用，I/O异步
热门推荐
u014028063的博客
08-04 1万+
上文介绍了python网络编程的进程线程，多线程，多进程相关，接下来介绍协程 Python由于众所周知的GIL的原因，导致其线程无法发挥多核的并行计算能力（当然，后来有了multiprocessing，可以实现多进程并行）。既然在GIL之下，同一时刻只能有一个线程在运行，那么对于CPU密集的程序来说，线程之间的切换开销就成了拖累，而以I/O为瓶颈的程序正是协程所擅长的： 多任务并发（非并行），...
浅谈Linux 网络 I/O 模型简介（图文）
09-15
根据UNIX网络编程的分类，Linux提供了五种I/O模型，分别是阻塞I/O、非阻塞I/O、I/O复用模型、信号驱动I/O以及异步I/O。 1. **阻塞I/O模型**： 在这个模型中，进程调用如`recvfrom`这样的系统调用时，会一直等待...
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
C++中I/O模型之select模型实例
09-04
如果需要处理更多套接字，可以考虑使用其他I/O模型，如`epoll`（在Linux系统中）或`IOCP`（在Windows系统中）。 总的来说，`select`模型在C++中的使用涉及到套接字的创建、监听、连接接受以及对文件描述符集合的...
Linux I/O多路复用详解及实例
09-15
Linux I/O多路复用是一种高效的编程模型，它允许单个进程同时监视多个I/O事件，从而提高了系统的并发处理能力。在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I...
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1071
删除链表节点
189.二叉树：将有序数组转换为二叉搜索树（力扣）
weixin_63779802的博客
06-21 206
代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
【算法】二叉树 - 理论基础
Nanki_的博客
06-23 1113
int val;
面试+算法之回文(Java)：验证回文串、回文数、最长回文子串、回文链表、分割成回文串、最短回文串、
lonelymanontheway的博客
06-20 519
验证回文串、回文数、最长回文子串、分割成回文串、最短回文串、回文链表
【代码随想录】【算法训练营】【第49天】 [300]最长递增子序列 [674]最长连续递增序列 [718]最长重复子数组
最新发布
weixin_54954007的博客
06-24 408
思路及算法思维，指路。题目来自。day 49，周二，坚持不了一点~
Linux IO模型/epoll
04-24
Linux IO模型/epoll

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值