27.epoll(一)

最新推荐文章于 2025-11-23 16:07:50 发布
原创 最新推荐文章于 2025-11-23 16:07:50 发布 · 738 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#服务器 #网络 #运维 #linux #c++ #开发语言 #1024程序员节

一.I/O多路转接之epolI

二.epoll接口详解

这些事件也是宏定义,和poll也是差不多的

三.epoll的原理 & 接口重弹

我们要指向对应的tcp_sock结构,因为sock是结构体的第一个成员,所以我们可以进行强转

这个sock,inet_sock等都是一套继承体系

UDP和TCP的区别就是UDP没有对应的inet_connection_sock(链接管理相关)

在上层都叫我们对应的sock,下层进行了封装

select会将我们对应的文件描述符表进行遍历,发现有对应的信息就向上返回(但是这样效率太低了)

但是这里不是我们对应的select的实现机制(信号驱动式IO的原理)

一个节点代表,一个文件描述符和用户要关心的该文件描述符的所有事件

那我们怎么知道红黑树该节点已经就绪了呢?

整体的这一套就叫做我们的epoll模型(宏观模型)

只要移动指针就能实现对应的将节点信息移动到就绪队列中

所以后续我们操作对应的epoll模型就是对文件描述符进行操作

四.epoll代码编写

#pragma once

#include <iostream>
#include <string>
#include <memory>
#include <sys/epoll.h>
#include "Log.hpp"
#include "Socket.hpp"

using namespace SocketModule;
using namespace LogModule;


const int gdefaultfd = -1;


// 最开始的时候,我们的服务器,只有一个文件描述符
class EpollServer
{
    static const int revs_num = 64;
public:
    EpollServer(int port) : _port(port),
                             _listen_socket(std::make_unique<TcpSocket>()),
                             _isrunning(false),
                             _epfd(gdefaultfd)
    {
    }
    void Init()
    {
        _listen_socket->BuildTcpSocket(_port);
        //1.创建epoll模型
        _epfd = epoll_create(256);
        if(_epfd < 0)
        {
            LOG(LogLevel::ERROR) << "epoll create error";
            exit(EPOLL_CREATE_ERR);
        }
        LOG(LogLevel::DEBUG) << "epoll_create success" << _epfd;

        //2.将listensocket添加到epoll模型中
        struct epoll_event ev;
        ev.events = EPOLLIN;
        ev.data.fd = _listen_socket->Fd();
        int n = epoll_ctl(_epfd,EPOLL_CTL_ADD,_listen_socket->Fd(),&ev);
        if(n < 0)
        {
            LOG(LogLevel::ERROR) << "epoll ctl error";
            exit(EPOLL_CTL_ERR);
        }
    }
    void Loop()
    {
        int timeout = 10000;
        _isrunning = true;
        while (_isrunning)
        {
            int n = epoll_wait(_epfd,_revs,revs_num,timeout);
            //完成通知上层的任务
            switch (n)
            {
            case 0:
                std::cout << "time out..." << std::endl;
                break;
            case -1:
                perror("select");
                break;
            default:
                // rfds: 内核告诉用户,你关心的rfds中的fd,有哪些已经就绪了
                Dispatcher(n);
                break;
            }
        }
        _isrunning = false;
    }
    void Accepter()
    {
        InetAddr client;
        // listensockfd就绪了! 再获取新连接
        int newfd = _listen_socket->Accepter(&client);
        // 这里进行accept不会被阻塞了,因为我们是被select叫来的,只执行拷贝
        if (newfd < 0)
        {
            return;
        }
        else
        {
            std::cout << "获取了一个新的连接: " << newfd << " client info: " << client.Addr() << std::endl;
            //我们要将其添加到对应的epoll,让epoll帮我们进行监管
            struct epoll_event ev;
            ev.events = EPOLLIN;
            ev.data.fd = newfd;
            int n = epoll_ctl(_epfd,EPOLL_CTL_ADD,newfd,&ev);
            if(n < 0)
            {
                LOG(LogLevel::ERROR) << "epoll ctl error";
                close(newfd);
            }
            LOG(LogLevel::DEBUG) << "epoll ctl success: " << newfd;
        }
    }
    void Recver(int fd)
    {
        char buffer[1024];
        ssize_t n = recv(fd,buffer,sizeof(buffer)-1,0);
        if(n > 0)
        {
            buffer[n] = 0;
            std::cout << "client# " <<buffer << std::endl;
            std::string message = "echo# ";
            message += buffer;
            send(fd,message.c_str(),message.size(),0);
        }
        else if(n == 0)
        {
            LOG(LogLevel::DEBUG) << "客户端退出, sockfd: " << fd;
            
            //把对应的文件描述符从epoll中进行移除
            //在移除的时候,我们应该将其先进行移除,再关闭
            int m = epoll_ctl(_epfd,EPOLL_CTL_DEL,fd,nullptr);
            if(m < 0)
            {
                LOG(LogLevel::ERROR) << "epoll ctl error";
                return;
            }
            LOG(LogLevel::DEBUG) << "epoll ctl success: " << fd;
            close(fd);
        }
        else
        {
            LOG(LogLevel::DEBUG) << "客户端读取出错, sockfd: " << fd;
            
            //把对应的文件描述符从epoll中进行移除
            int m = epoll_ctl(_epfd,EPOLL_CTL_DEL,fd,nullptr);
            if(m < 0)
            {
                LOG(LogLevel::ERROR) << "epoll ctl error";
                return;
            }
            LOG(LogLevel::DEBUG) << "epoll ctl success: " << fd;
            close(fd);
        }
    }

    void Dispatcher(int rnum)
    {
        for (int i = 0; i < rnum; i++)
        {
            int events = _revs[i].events;
            int fd = _revs[i].data.fd;
            if(fd == _listen_socket->Fd())
            {
                if(events & EPOLLIN)
                {
                    //listen sock fd
                    Accepter();
                }
            }
            else
            {
                if(events & EPOLLIN)
                {
                    //读事件就绪
                    Recver(fd);
                }
                // else if(events & EPOLLOUT)
                // {
                //     //写事件就绪
                // }
            }
        }
    }
    ~EpollServer()
    {
        _listen_socket->Close();
        if(_epfd >= 0)
        {
            close(_epfd);
        }
    }

private:
    uint16_t _port;
    std::unique_ptr<Socket> _listen_socket;
    bool _isrunning;
    int _epfd;
    struct epoll_event _revs[revs_num];
};

五.epoll的工作模式: ET && LT

1.什么是ET,LT?

(LT模式)水平触发模式: 只要底层有数据,就一直告知上层,条件是就绪的

(ET模式)边缘触发模式: 当收到新的数据是就会通知对方一次!(从无到有,从有到多,变化(增多)的时候,才进行通知对方)

所谓的张三就是我们对应的 (epoll && LT),快递就是我们对应的数据,小车就是我们的输入缓冲区

打电话就是我们的通知机制

所以ET单位时间内,IO吞吐量更多

但是ET这样做是有代价的!!!

2.为啥要有LT,ET?

3.各自的特点是什么?我应该用哪一个?

根据我们的场景进行使用即可

六.epoll代码的设计

1.软件分层的设计

我们对应的EpollServer向上看到的都是我们对应的Connection

2.epoller模型封装(最基本的检测模型(底层))

#pragma once


#include <iostream>
#include <sys/epoll.h>
#include "Log.hpp"
#include "Common.hpp"

using namespace LogModule;

namespace EpollModule
{
    class Epoller
    {
    public:
        Epoller():_epfd(-1)
        {

        }
        void Init()
        {
            _epfd = ::epoll_create(256);
            if(_epfd < 0)
            {
                LOG(LogLevel::ERROR) << "epoll_create error";
                exit(EPOLL_CREATE_ERR);
            }
            LOG(LogLevel::INFO) << "epoll_create success, epfd: " << _epfd;
        }
        int Wait(struct epoll_event revs[],int num) //输出就绪的fd和events
        {
            int n = epoll_wait(_epfd,revs,num,-1);
            if(n < 0)
            {
                LOG(LogLevel::WARNING) << "epoll_create error";
            }
            return n;
        }
        void Ctrl(int sockfd,uint32_t events)
        {
            struct epoll_event ev;
            ev.events = events;
            ev.data.fd = sockfd;
            int n = epoll_ctl(_epfd,EPOLL_CTL_ADD,sockfd,&ev);
            if(n < 0)
            {
                LOG(LogLevel::WARNING) << "epoll_ctl error";
            }
        }
        ~Epoller()
        {

        }
    private:
        int _epfd;
    };
};

3.EpollServer.hpp的设计

#pragma once 

#include <iostream>
#include <memory>
#include <unordered_map>
#include "Epoller.hpp"
#include "Connection.hpp"

using namespace EpollModule;
using connection_t = std::shared_ptr<Connection>;

class EpollServer
{
    const static int event_num = 64;
public:
    EpollServer():_isrunning(false),_epoller(std::make_unique<Epoller>())
    {
        _epoller->Init();
    }
    void InsertConnection(connection_t& conn)
    {
        auto iter = _connections.find(conn->sockfd());
        if(iter == _connections.end())
        {
            //1.将链接放到unordered_map中
            _connections.insert(std::make_pair(conn->sockfd(),conn));
            //2.插入的链接写入epoll中
            _epoller->Ctrl(conn->sockfd(),conn->GetEvents());
        }
    }
    bool IsConnectionExists(int sockfd)
    {
        return _connections.find(sockfd) == _connections.end();
    }
    void Loop()
    {
        _isrunning = true;
        while(_isrunning)
        {
            int n = _epoller->Wait(_revs,event_num);
            for(int i = 0;i < n;i++)
            {
                //开始派发任务
                int sockfd = _revs[i].data.fd;
                uint32_t revents = _revs[i].events;
                if((revents & EPOLLERR) || (revents & EPOLLHUP))
                {
                    revents = (EPOLLIN | EPOLLOUT);//异常事件转换成为读写事件
                }
                if((revents & EPOLLIN) && IsConnectionExists(sockfd))
                {
                    _connections[sockfd]->CallRecv();
                }
                if((revents & EPOLLOUT) && IsConnectionExists(sockfd))
                {
                    _connections[sockfd]->CallSend();
                }
            }
        }
        _isrunning = false;
    }
    void Stop()
    {
        _isrunning = false;
    }
    ~EpollServer()
    {

    }
private:
    std::unique_ptr<Epoller> _epoller;
    std::unordered_map<int,connection_t> _connections; //服务器内部所有的链接
    bool _isrunning;
    struct epoll_event _revs[event_num];
};

4.Connection.hpp的设计

#pragma once

#include <iostream>
#include <string>
#include <functional>
#include "InetAddr.hpp"
// #include "EpollServer.hpp"

class EpollServer;

using func_t = std::function<void()>;




// 普通 fd,  Listensockfd
//让我们对fd的处理方式采用同一种方式
//描述一个链接
class Connection
{
public:
    Connection(int sockfd):_sockfd(sockfd),_events(0)
    {

    }
    void InitCB(func_t recver,func_t sender,func_t excepter)
    {
        _recver = recver;
        _sender = sender;
        _excepter = excepter;
    }
    void SetPeerInfo(const InetAddr& peer_addr)
    {
        _peer_addr = peer_addr;
    }
    int sockfd()
    {
        return _sockfd;
    }
    void SetEvents(uint32_t events)
    {
        _events = events;
    }
    uint32_t GetEvents()
    {
        return _events;
    }
    void CallRecv()
    {
        if(_recver != nullptr)
        {
            _recver();
        }
    }
    void CallSend()
    {
        if(_sender != nullptr)
        {
            _sender();
        }
    }
    ~Connection()
    {

    }
private:
    int _sockfd;
    std::string _inbuffer;
    std::string _outbuffer;

    InetAddr _peer_addr; //对应的客户端

    //回调方法
    func_t _recver;
    func_t _sender;
    func_t _excepter;

    //添加一个指针
    EpollServer* _owner;

    //关心的事件
    uint32_t _events;
};

5.Listener.hpp的设计

#pragma once

#include <iostream>
#include <memory>
#include "Socket.hpp"
#include "Log.hpp"

using namespace SocketModule;
using namespace LogModule;

//专门负责获取链接的模块
class Listener
{
public:
    Listener(int port)
        :_listensock(std::make_unique<TcpSocket>()),
        _port(port)
    {
        _listensock->BuildTcpSocket(port);
    }
    int Sockfd()
    {
        return _listensock->Fd();
    }
    void Accepter()
    {
        LOG(LogLevel::DEBUG) << "hahaha accepter";
    }
    ~Listener()
    {
        _listensock->Close();
    }
private:
    int _port;
    std::unique_ptr<Socket> _listensock;
};

6.Main.cpp设计

#include <iostream>
#include <string.h>
#include "Log.hpp"
#include "Listener.hpp"
#include "Connection.hpp"
#include "EpollServer.hpp"


using namespace LogModule;


int main(int argc,char* argv[])
{
    if(argc != 2)
    {
        std::cout << "Usage: " << argv[0] << " port" << std::endl;
        return 1;
    }
    ENABLE_CONSOLE_LOG();
    uint16_t local_port = std::stoi(argv[1]);

    Listener listen(local_port);//完成具体工作的模块
    //我们要把listensockfd,封装成为一个Connection,并将其托管给EpollServer
    connection_t conn = std::make_shared<Connection>(listen.Sockfd());
    conn->InitCB(
        [&listen](){
            listen.Accepter();
        }
        ,nullptr
        ,nullptr
    );
    conn->SetEvents(EPOLLIN|EPOLLET);
    

    EpollServer epoll_svr;
    epoll_svr.InsertConnection(conn);
    epoll_svr.Loop();
    return 0;
}

7.代码修改

class Connection
{
public:
    Connection(int sockfd):_sockfd(sockfd),_events(0)
    {

    }
    void InitCB(func_t recver,func_t sender,func_t excepter)
    {
        _recver = recver;
        _sender = sender;
        _excepter = excepter;
    }
    void SetPeerInfo(const InetAddr& peer_addr)
    {
        _peer_addr = peer_addr;
    }
    int sockfd()
    {
        return _sockfd;
    }
    void SetEvents(uint32_t events)
    {
        _events = events;
    }
    uint32_t GetEvents()
    {
        return _events;
    }
    void CallRecv()
    {
        if(_recver != nullptr)
        {
            _recver();
        }
    }
    void CallSend()
    {
        if(_sender != nullptr)
        {
            _sender();
        }
    }
    ~Connection()
    {

    }
private:
    int _sockfd;
    std::string _inbuffer;
    std::string _outbuffer;

    InetAddr _peer_addr; //对应的客户端

    //回调方法
    func_t _recver;
    func_t _sender;
    func_t _excepter;

    //添加一个指针
    EpollServer* _owner;

    //关心的事件
    uint32_t _events;
};



class Factory
{
public:
    static std::shared_ptr<Connection> BuildConnection
        (int fd,uint32_t events,func_t r,func_t w,func_t e)
    {
        auto conn = std::make_shared<Connection>(fd);
        conn->SetEvents(events);
        conn->InitCB(r,w,e);
        return conn;
    }
};


#include <iostream>
#include <string.h>
#include "Log.hpp"
#include "Listener.hpp"
#include "Connection.hpp"
#include "EpollServer.hpp"


using namespace LogModule;


int main(int argc,char* argv[])
{
    if(argc != 2)
    {
        std::cout << "Usage: " << argv[0] << " port" << std::endl;
        return 1;
    }
    ENABLE_CONSOLE_LOG();
    uint16_t local_port = std::stoi(argv[1]);
    Listener listen(local_port);
    auto conn = Factory::BuildConnection(listen.Sockfd(),EPOLLIN|EPOLLET,[&listen](){
            listen.Accepter();
        }
        ,nullptr
        ,nullptr);
    

    EpollServer epoll_svr;
    epoll_svr.InsertConnection(conn);
    epoll_svr.Loop();
    return 0;
}

void SetNonBlock(int sockfd)
{
    int fl = fcntl(sockfd,F_GETFL);
    if(fl < 0)
    {
        return;
    }
    fcntl(sockfd,F_SETFL,fl | O_NONBLOCK);
}

未完待续....

epoll 的接口介绍
weixin_45629738的博客
04-01 956
epoll 是 Linux 特有的 I/O 复用函数。 它在实现和使用上与 select、poll 有很大差异。 首先，epoll 使用一组函数来完成任务，而不是单个函数。 其次，epoll 把用户关心的文件描述符上的事件放在内核里的一个事件表中。 从而无需像 select 和 poll 那样每次调用都要重复传入文件描述符或事件集。 但 epoll 需要使用一个额外的文件描述符，来唯一标识内核中的这个事件表。 epoll 相关的函数如下： ◼ epoll_create()用于创建内核事件表 ◼ epol.
C语言笔记-27-网络-多路复用epoll
宝全哥哥的博客
12-14 928
自学笔记，没有历史知识铺垫（省略百度部分）C语言笔记-27-网络-多路复用epoll本章主要为C语言笔记-27-网络-多路复用epoll。
27.epoll(二)
weixin_60668256的博客
11-21 532
IOService只是进行连接的获取,而我们对应的Listener只是进行连接的建立,处理信息式交给我们对应的上层的。我们虽然将一轮全部都读取完了,但是我们还不能确定报文是否读取完整了(所以我们要引入对应的协议)上面的整体我们已经完成了,所以现在我们对应的矛盾就转移到了对应的IOService了。这个是关于我们对应的epoll模型的,不进行改变。上一篇博客的代码我们将会进行一些微调。那么我们如何发送数据呢?这里我们将方法抽离出来。
27.epoll(三)
weixin_60668256的博客
11-21 299
我们这里使用的是用户空间用于我们文件描述符的传递,事件通知用我们对应的eventfd。我们使用管道,既可以唤醒对应的Reactor,也可以唤醒对应的条件变量。每次发送消息和接收消息,都进行更新时间(这样我们就能做连接管理了)有任何一个请求到了,Master进程不做任何的处理,直接通知子进程。由一个Master创建多个子进程,然后用管道进行通信。我可以用以前的客户端来向我们的服务器进行发起请求。我们要将给文件描述符的关心事件全部都进行更改。epoll啥都能进行关心(包括管道)
并发编程
weixin_34336292的博客
05-16 872
title: 并发编程 tags: 并发 categories: 并发 date: 2019-04-23 17:11:23 前言：并发编程存在的问题 1. 上下文切换的问题 ​ 即使是单核CPU也支持多线程执行。是通过给每个线程分配CPU时间片的方式来实现这个机制，给人的感官就像是多个线程同时执行。每个时间片都是一般默认是几十毫秒。 ​ CPU通过时间片分配算法循环执行任务，当前任务执行完一个时...
Arthas实战全录
FeelTouch Labs
02-19 1319
一、Arthas基础认识 1. 可以做什么？ Arthas 是Alibaba开源的Java诊断工具，采用命令行交互模式，提供了丰富的功能，是排查jvm相关问题的利器。 在逛github时，发现了这款利器，深入了解之后，简直惊为天人。下面先列举一下它能做的一些事情： 提供性能看板，包括线程、cpu、内存等信息，并且会定时的刷新。 根据各种条件查看线程快照。比如找出cpu占用率最高的n个线程等 输出jvm的各种信息，如gc算法、jdk版本、ClassPath等 查看/设置sysprop和sysenv
同样代码 linux下cpu过高,linux cpu过高原因及代码定位
weixin_39825259的博客
05-12 542
1. top命令查看CPU和内存占用率top回车，然后按1发现进程PID 35163 CPU和内存占用率都很高top - 06:13:47 up 5:31, 1 user, load average: 2.11, 2.07, 2.06Tasks: 189 total, 1 running, 188 sleeping, 0 stopped, 0 zombieCpu0 : 22.3...
epoll的ET模式与LT模式
YanWenCheng_的博客
02-10 281
LT一般默认模式 1 #include"wrap.h" 2 #include<errno.h> 3 #include<sys/epoll.h> 4 #define MAX_EVENT_NUM 1024 5 #define BUFF_SIZE 10 6 7 void delfd (int epollfd ,int fd) 8 { 9 ...
epoll 性能分析（解决占用CPU 过高问题）
dfrzx9139的博客
03-09 2414
针对自己写的一个服务器网络引擎Engine 文章后面附上源码 使用epoll 刚刚开始时候发现占用CPU 特别高，但是网络引擎里面基本没干什么事，不应该有这么高的CPU，一直不解， 于是自己慢慢的分析服务器工作线程，发现主要的性能消耗应该是处理IO 时候， int nEventNum = epoll_wait(m_nEpId, arrEvents, default_epoll_s...
windows版本的epoll
yuanshenqiang的博客
05-02 1599
读zeromq源码，发现一个有意思的事情。它竟然包含了一个windows版本的epoll，之前一直以为它在windows下面用的时select IO复用模型，没想到不是。这个wepoll好像是个第三方开源的组件，能被zeromq认可，说明写的还是不错的。接口基本上和linux的epoll一致，简单尝试了一下，用起来确实顺手多了，以后写跨平台的网络基础框架，可以借用一下。这个组件库的master分支内容比较多，zeromq中用的是它的dist分支，只有两个文件：wepoll.h和wepoll.cpp。
java笔试题2015-sparrow:一个高效的web/http服务器...（多线程&&非阻塞I/O&&epoll）
06-03
这是一个基于epoll而写的一个简单高效的http server, 该server能轻松应对并发问题(单进程+eventloop+IO复用+非阻塞IO). 该httpd目前的功能很简单，接收http请求，返回“hello evlib”。 #News 2015-04-10日晚11:20分...
2025-10-14 14:30:27.255 [scheduling-1] INFO [] [] [] io.lettuce.core.EpollProvider - Starting without optional epoll library 2025-10-14 14:30:27.257 [scheduling-1] INFO [] [] [] io.lettuce.core.KqueueProvider - Starting without optional kqueue library 2
10-15
首先，用户的问题是关于Lettuce库启动时提示"Starting without optional epoll library"和"Starting without optional kqueue library"的原因及解决方案。用户提供的引用内容中提到了Lettuce支持epoll和kqueue，但...
服务器无故nginx异常关闭之kauditd0 kswapd0挖矿病毒 CPU占用200% 内存耗尽
2509_94007132的博客
11-23 211
当我用 命令 kill -9 kaudiod0 杀死进程后，没过一会儿，进程又自动开起来了。发现8G的内存快被占用光了，而我们只开了一个开销不大的java服务，按道理1G就够了。网上搜索教程上是kswapd0，而此次我们服务器上是 kswapd00。，这可能意味着原始启动它的进程或会话已经结束，但该进程仍然在运行。的 systemd 服务单元中运行的，该服务单元是为用户。发现有个kauditd0进程占用了200% 的CPU。的会话 189 创建的。发现有各种德国 美国的IP，因此可以确认是中毒了。
从管道到共享内存：深入理解 Linux 进程间通信
m0_67804957的博客
11-19 917
本文深入探讨了Linux系统中的三种关键进程间通信(IPC)机制。首先介绍了匿名管道，它仅适用于有亲缘关系的进程间通信，具有单向性；随后讲解命名管道(FIFO)，通过文件系统路径实现无关进程间的通信；最后重点分析了最高效的共享内存方式，它通过内存映射实现零拷贝通信。文章详细阐述了每种机制的原理、特点和使用场景，并提供了具体的代码实现示例，包括管道封装类和共享内存管理类。特别强调了共享内存的创建、挂接、使用和释放流程，以及其无保护机制带来的并发问题，为后续同步机制讨论奠定了基础。
使用 Spring AI 创建 MCP 服务器
dancuowang的博客
11-20 892
本文提供了使用 Spring AI 创建模型上下文协议服务器的分步指南，并阐述了使用 MCP 的优势。
DHCP 服务器
2202_75295990的博客
11-20 1502
DHCP服务器简介与配置 DHCP（动态主机配置协议）自动分配网络参数，解决IP地址管理问题。通信过程包括DISCOVER、OFFER、REQUEST和ACK四个阶段。配置DHCP服务器需安装dhcp软件包，修改/etc/dhcp/dhcpd.conf文件，定义子网范围、DNS服务器等参数。服务器支持动态IP分配和静态IP绑定，通过MAC地址指定固定IP。租约时间可配置，默认600秒，最大7200秒。注意同一网络应避免多个DHCP服务器，否则可能导致地址冲突。
流媒体存储服务器阵列缺盘64TB多媒体文件的修复方法
CHS实验室
11-21 967
摘要：本文介绍了一台64TB RAID5存储服务器因三块硬盘故障导致阵列崩溃后的多媒体文件修复过程。由于RAID5最多允许一块硬盘离线，而实际缺失两块硬盘，导致数据恢复困难。通过分析发现存储的是RTP推流的MP4格式文件，存在视频编码混乱、设备版本差异及音画同步三大难题。最终通过深入研究RTP协议和MP4文件结构，创新性地解决了音频修复和音画同步问题，采用"蚂蚁搬家"方式逐步修复了大量文件，取得了客户满意的效果。案例展示了复杂存储环境下数据恢复的技术挑战和解决方案。
秒级创建鲲鹏工程进行原生开发
优快云高校俱乐部官方博客
11-21 397
秒级创建鲲鹏工程进行原生开发
webserver服务器信号处理流程
最新发布
2203_75974353的博客
11-23 675
你的理解实际流程信号触发 -> epoll 检测到信号信号触发 -> 信号处理函数被调用 -> 向管道写端写入一个字节-> 管道读端变为可读 ->epoll 检测到读事件-> 调用对应函数处理-> 主循环调用函数 -> 从管道读端读出信号值 -> 根据信号值调用对应函数处理信号中文含义触发源对应事件服务器典型处理动作SIGTERM终止信号外部命令 (kill <pid>管理员要求服务器关闭启动优雅关闭流程，安全释放所有资源后退出。SIGALRM闹钟信号内部alarm()函数。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值