muduo库的模拟实现——Reactor部分

最新推荐文章于 2024-05-20 16:40:58 发布

JJP不会CPP

最新推荐文章于 2024-05-20 16:40:58 发布

阅读量1.3k

点赞数 15

分类专栏： muduo库文章标签： linux 服务器 c++ mysql 数据库算法

本文链接：https://blog.csdn.net/2301_76366823/article/details/135977604

版权

muduo库专栏收录该内容

4 篇文章 1 订阅

订阅专栏

一、Channel模块

事实上Channel模块并不算是一个单独的模块，顶多算是一个单独的类。Channel模块和EventLoop模块、Poller模块是紧密关联的，其中通过EventLoop模块创建出来的对象就是一个Reactor，EventLoop对象里面有一个Poller对象，用来监控事件。至于监控什么样的事件，是可读事件还是可写事件，以及各种事件触发以后该调用什么回调函数去处理，这就是由EventLoop对象通过Channel来设置的了。

Channel模块一共管理五类事件，分别是：可读事件、可写事件、错误事件、连接断开事件以及任意事件。每种事件都要设置事件触发后的回调函数。所以Channel模块的成员变量需要这五类事件触发后的回调函数。另外还需要绑定一个EventLoop对象，也就是说一个Channel对象是绑定一个EventLoop对象的，因为设置好了事件以后，需要通过EventLoop对象的Poller对象将Channel事件监控起来。当然了，Channel对象监控的文件描述符以及需要监控的事件也必须要有，所以这就是Channel类的成员变量：

private:
    int _fd;                       // socket文件描述符
    uint32_t _events;              // 当前需要监控的事件
    uint32_t _revents;             // 当前连接触发的事件
    EventCallBack _read_callback;  // 可读事件被触发的回调函数
    EventCallBack _write_callback; // 可写事件被触发的回调函数
    EventCallBack _error_callback; // 错误事件被触发的回调函数
    EventCallBack _close_callback; // 连接断开事件被触发的回调函数
    EventCallBack _event_callback; // 任意事件被触发的回调函数
    EventLoop *_eventLoop;
};

Channel类比较重要的一个接口是handlerEvent函数接口，这个接口是真正的事件处理接口，一旦事件触发了，就会调用这个函数。也就是说这个函数是被上层调用的，具体的调用逻辑是：当Poller模块监控到有事件触发时，就将触发事件的文件描述符对应的Channel对象返回，返回给EventLoop对象，EventLoop对象再调用该Channel对象的handlerEvent函数，去执行触发事件对应的回调函数。

    // 事件处理，一旦连接触发了事件，就调用这个函数
    void handlerEvent()
    {
        // EPOLLIN: 可读事件触发
        // EPOLLRDHUP: 对端关闭了连接，表示读关闭
        // ？思考为什么对端关闭连接要调用可读事件回调函数，猜测与缓冲区还有数据有关
        // EPOLLPRI：表示有紧急数据需要读取
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            // // 不管是什么事件，都要调用任意事件回调函数
            // if (_event_callback)
            // {
            //     _event_callback();
            // }
            if (_read_callback)
            {
                _read_callback();
            }
        }
        // EPOLLOUT：表示写事件触发
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
            {
                _write_callback();
            }
        }
        // EPOLLERR：表示出错
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
            {
                _error_callback();
            }
        }
        // EPOLLHUP：表示连接关闭
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
            {
                _close_callback();
            }
        }
        // 不管是什么事件，都要调用任意事件回调函数
        if (_event_callback)
        {
            _event_callback();
        }
    }

其它的实现都比较简单，就是在设置对应的事件以及事件触发的回调函数，这里就不过多介绍了，看代码就能看得懂，Channel类完整代码如下：

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

class EventLoop;

/// @brief Channel是事件管理类，用来管理eventLoop对象所关心的所有事件
class Channel
{
public:
    /// @brief 构造函数
    /// @param eventLoop 需要传入EventLoop对象来初始化Channel，因为Channel管理的是EventLoop对象的事件，
    ///                  EventLoop对象就是一个reactor，EventLoop对象里面有一个Poller对象用来监控事件
    ///                  至于监控什么事件，这就是由EventLoop对象通过Channel来设置了，这就是三者之间的关系
    /// @param fd 还需要用文件描述符来初始化，因为必须要知道Channel要管理的事件是哪一个文件描述符的事件
    Channel(EventLoop *eventLoop, int fd)
        : _fd(fd), _events(0), _revents(0), _eventLoop(eventLoop)
    {
    }

    int getFd()
    {
        return _fd;
    }

    void setRevents(uint32_t events)
    {
        _revents = events;
    }

    // 当前是否监控了可读
    bool isReadAble()
    {
        return (_events & EPOLLIN);
    }

    // 当前是否监控了可写
    bool isWriteAble()
    {
        return (_events & EPOLLOUT);
    }

    // 启动读事件监控
    void startReadAbleEvent()
    {
        _events |= EPOLLIN;
        // 这里需要调用updateEvent函数接口，用来更新_events
        // 这个接口是Channel类实现的，但是这个接口其实调用的是eventLoop对象的updateEvent函数接口
        // 它的逻辑链是Channel更新了_event事件，就要交给Poller监控模块进行监控
        // 但是这不能跳过eventLoop对象，因为reactor才是操作Channel和Poller的主体
        // 所以必须调用eventLoop对象的更新事件函数接口，然后eventLoop对象再调用Poller类的更新事件接口
        // 这样就能将事件更新到Poller模块，实现新事件的监控
        updateEvent();
    }

    // 启动写事件监控
    void startWriteAbleEvent()
    {
        _events |= EPOLLOUT;
        updateEvent();
    }

    // 关闭读事件监控
    void closeReadAbleEvent()
    {
        _events &= ~EPOLLIN;
        updateEvent();
    }

    // 关闭写事件监控
    void closeWriteAbleEvent()
    {
        _events &= ~EPOLLOUT;
        updateEvent();
    }

    // 关闭所有事件监控
    void closeAllEvent()
    {
        _events = 0;
        updateEvent();
    }

    void updateEvent();

    // 移除监控
    void removeEvent();

    // 移除所有监控
    void removeAllEvents();

    // 设置可读事件回调函数
    // 这个回调函数由外界传入，当revent事件就绪时，会首先检查就绪的事件是什么类型的事件
    // 这里设置可读事件、可写事件等等的回调函数，目的是在对应事件就绪时，可以调用对应的回调函数去处理
    void setReadAbleCallBack(const EventCallBack &callBack)
    {
        _read_callback = callBack;
    }

    // 设置可写事件回调函数
    void setWriteAbleCallBack(const EventCallBack &callBack)
    {
        _write_callback = callBack;
    }

    // 设置错误事件回调函数
    void setErrorCallBack(const EventCallBack &callBack)
    {
        _error_callback = callBack;
    }

    // 设置连接关闭事件回调函数
    void setCloseCallBack(const EventCallBack &callBack)
    {
        _close_callback = callBack;
    }

    // 设置任意事件回调函数
    void setEventCallBack(const EventCallBack &callBack)
    {
        _event_callback = callBack;
    }

    // 事件处理，一旦连接触发了事件，就调用这个函数
    void handlerEvent()
    {
        // EPOLLIN: 可读事件触发
        // EPOLLRDHUP: 对端关闭了连接，表示读关闭
        // ？思考为什么对端关闭连接要调用可读事件回调函数，猜测与缓冲区还有数据有关
        // EPOLLPRI：表示有紧急数据需要读取
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            // // 不管是什么事件，都要调用任意事件回调函数
            // if (_event_callback)
            // {
            //     _event_callback();
            // }
            if (_read_callback)
            {
                _read_callback();
            }
        }
        // EPOLLOUT：表示写事件触发
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
            {
                _write_callback();
            }
        }
        // EPOLLERR：表示出错
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
            {
                _error_callback();
            }
        }
        // EPOLLHUP：表示连接关闭
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
            {
                _close_callback();
            }
        }
        // 不管是什么事件，都要调用任意事件回调函数
        if (_event_callback)
        {
            _event_callback();
        }
    }

    uint32_t getEvent()
    {
        return _events;
    }

private:
    int _fd;                       // socket文件描述符
    uint32_t _events;              // 当前需要监控的事件
    uint32_t _revents;             // 当前连接触发的事件
    EventCallBack _read_callback;  // 可读事件被触发的回调函数
    EventCallBack _write_callback; // 可写事件被触发的回调函数
    EventCallBack _error_callback; // 错误事件被触发的回调函数
    EventCallBack _close_callback; // 连接断开事件被触发的回调函数
    EventCallBack _event_callback; // 任意事件被触发的回调函数
    EventLoop *_eventLoop;
};

void Channel::removeEvent()
{
    _eventLoop->removeEvent(this);
}

void Channel::updateEvent()
{
    _eventLoop->updateEvent(this);
}

二、Poller模块

Poller模块负责的是监控事件，事实上就是封装了epoll多路转接那一套操作，它的成员变量如下：这里可以简单介绍一下_channels这个哈希表结构，之所以需要这个结构，是因为EventLoop模块向Poller模块新增事件的时候，Poller模块也需要通过_channels这个结构将这些Channel对象管理起来，当Poller监控到事件触发的时候，可以直接从_channels里找到对应的Channel对象返回给上层，上层再直接调用Channel对象的handlerEvent函数即可。

private:
    int _epfd;                            // epoll模型对应的epollfd
    epoll_event _events[MAX_EPOLLEVENTS]; // 用来接收就绪事件的数组
    // 用来保存Channel对象的哈希表，key值是Channel对象管理的事件对应的文件描述符，value值是Channel对象
    // Poller类是与EventLoop类关联起来的，EventLoop对象里面有一个Poller对象
    // Poller对象里面管理的事件不止一个，管理的文件描述符也不止一个，同一个文件描述符下的不同事件通过Channel对象来管理
    // 不同的文件描述符对应的Channel对象就通过这个_channels成员变量来管理
    std::unordered_map<int, Channel *> _channels;

Poller模块的实现也比较简单，因为就是epoll那一套操作，这里简单介绍一下几个函数接口的作用即可。首先在Poller类的构造函数处调用epoll_create创建epoll模型，然后updateEvent函数是给外部调用来添加或者修改监控事件的，removeEvent则是移除监控事件，最后poll函数是外部调用来启动epoll监控的，这个函数会调用epoll_wait函数接口去等待事件就绪，有事件就绪以后就从_channels里面找到对应的Channel对象返回。Poller类的完整代码如下：

#define MAX_EPOLLEVENTS 1024

class Poller
{
public:
    /// @brief 构造函数，需要调用epoll_create创建epoll模型
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            LOG("epoll_create error");
            abort();
        }
    }

    // 添加或修改监控事件
    void updateEvent(Channel *channel)
    {
        // 首先判断形参传递进来的Channel对象是否已经存在在_channels哈希表中
        // 如果存在就直接更新事件即可，如果不存在就先增加到哈希表中再更新事件
        bool isAddChannelRes = isAddChannel(channel);
        if (isAddChannelRes == false)
        {
            // 不存在则添加
            _channels.insert(std::make_pair(channel->getFd(), channel));
            if (!update(channel, EPOLL_CTL_ADD))
            {
                LOG("update error");
            }
        }
        else
        {
            if (!update(channel, EPOLL_CTL_MOD))
            {
                LOG("update error");
            }
        }
    }

    // 移除监控
    void removeEvent(Channel *channel)
    {
        // 首先要检查_channels哈希表中是否存在对应的channel对象，如果存在就要将其删除
        auto iter = _channels.find(channel->getFd());
        if (iter != _channels.end())
        {
            _channels.erase(iter);
        }
        // 然后更新事件
        if (!update(channel, EPOLL_CTL_DEL))
        {
            LOG("update error");
        }
    }

    // 开始监控，返回活跃连接
    void poll(std::vector<Channel *> *active)
    {
        // 调用epoll_wait函数接口，开始监控，就绪事件保存在_events数组中，返回值nfds表示就绪事件的个数
        int nfds = epoll_wait(_epfd, _events, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG("epoll_wait error");
            abort();
        }
        // 遍历_events数组中的所有就绪事件
        for (int i = 0; i < nfds; i++)
        {
            // 先通过就绪事件的文件描述符到_channels哈希表中查找
            auto iter = _channels.find(_events[i].data.fd);
            // 必须保证能够在_channels哈希表中找到对应的channel对象，找不到是不合理的
            assert(iter != _channels.end());
            // 找到了以后拿到该文件描述符对应的channel对象，设置给对象的revent就绪事件
            iter->second->setRevents(_events[i].events);
            // 然后将就绪事件加入active活跃连接数组中返回给外界
            active->push_back(iter->second);
        }
    }

    void clearChannels()
    {
        _channels.clear();
    }

private:
    // 对epoll的直接操作
    // 更新epoll模型中的事件，这个事件通过形参的channel对象获取
    // 可以是新增事件、修改事件、删除事件，通过op决定
    bool update(Channel *channel, int op)
    {
        int fd = channel->getFd();
        epoll_event event;
        event.data.fd = fd;
        event.events = channel->getEvent();
        int epollCtlRes = epoll_ctl(_epfd, op, fd, &event);
        if (epollCtlRes < 0)
        {
            LOG("epoll_ctl error");
            return false;
        }
        return true;
    }

    // 判断一个Channel是否已经添加了事件监控
    bool isAddChannel(Channel *channel)
    {
        auto iter = _channels.find(channel->getFd());
        if (iter == _channels.end())
        {
            return false;
        }
        return true;
    }

private:
    int _epfd;                            // epoll模型对应的epollfd在这里插入代码片
    epoll_event _events[MAX_EPOLLEVENTS]; // 用来接收就绪事件的数组
    // 用来保存Channel对象的哈希表，key值是Channel对象管理的事件对应的文件描述符，value值是Channel对象
    // Poller类是与EventLoop类关联起来的，EventLoop对象里面有一个Poller对象
    // Poller对象里面管理的事件不止一个，管理的文件描述符也不止一个，同一个文件描述符下的不同事件通过Channel对象来管理
    // 不同的文件描述符对应的Channel对象就通过这个_channels成员变量来管理
    std::unordered_map<int, Channel *> _channels;
};

3.EventLoop模块

EventLoop类是封装Reactor操作的类，我们先来看一下EventLoop类的成员变量：

_thread_id： 线程ID，由于我们要实现one loop one thread，即一个EventLoop对象绑定一个线程，一个线程创建一个EventLoop对象，所以我们需要一个线程ID来记录该EventLoop对象绑定的线程。
_tasks： 每一个EventLoop对象都有一个任务池，只有那些不允许被其它线程调用的任务会被加入到EventLoop的任务池中执行，如果被其他线程调用则可能会出现线程安全的问题。muduo解决这些线程安全问题的方案并不是加锁，因为不想因为加锁释放锁而影响效率，而是采用了EventLoop中一个很重要的函数——runInLoop，也就是将这些任务与EventLoop对象绑定起来，限制这些任务只能在这个EventLoop对象中被执行，而EventLoop对象又是与线程绑定的，所以也就限制了这些任务只能被一个线程执行，其它线程无法执行，这样就不存在线程安全问题了，这其实就是one loop one thread的思想。
_event_fd：eventfd是Linux内核提供的用来进行事件通知的文件描述符，它其实是内核维护的一个计数器。当用户向eventfd文件描述符写入数据时，eventfd的计数器就加一；当用户读取数据时，就会返回eventfd文件描述符里的值，这个值代表距离上一次读取数据，一共通知了多少次。muduo在这里使用eventfd机制，其实是想通过epoll模型将eventfd文件描述符监控起来，因为EventLoop对象会在有IO事件触发的时候才去执行任务池里的任务，但有些时候可能对方没有发数据过来，但有一个任务需要立即被处理，就有可能因为阻塞在等待epoll_wait事件就绪而导致任务无法处理。比如说有一个连接快要超时了，用户又刷新了连接，但并没有发送数据，这时为了不然服务器阻塞在等待epoll_wait的返回，我们就可以向eventfd文件描述符里写入一个数据，目的是通知epoll模型有事件到来，然后服务器从epoll_wait处返回，进而去执行刷新定时器的任务。这就是eventfd的用处。
_timerWheel：该成员变量就是时间轮对象，每一个EventLoop对象都要有一个时间轮对象，因为每个时间轮对象必须与EventLoop对象绑定，这样在执行新增定时器、刷新定时器任务、取消定时器任务这些函数时不会出现线程安全问题。想象一下，如果所有线程共用一个时间轮对象，就会有线程安全的问题，比如有一个线程刚准备去刷新定时器任务，就被切换走了，新线程上了执行了定时器销毁的动作，那就出问题了，因为按理说这个定时器任务应该被刷新不应该现在被销毁的。所以为了避免这种线程不安全的问题，我们让每个EventLoop对象用自己的时间轮对象，由于runInLoop函数的作用，这些定时器操作的函数不会被其它线程调用，也就不会出现线程不安全的问题了。

private:
    std::thread::id _thread_id;              // 线程ID
    int _event_fd;                           // eventfd唤醒IO事件监控有可能导致的阻塞
    Poller _poller;                          // 进行所有描述符的事件监控
    std::vector<Functor> _tasks;             // 任务池
    std::mutex _mutex;                       // 实现任务池操作的线程安全
    std::unique_ptr<Channel> _event_channel; // 这是管理eventfd的Channel对象
    TimerWheel _timerWheel;

接下来我们就要介绍一下EventLoop里很重要的一个函数——runInLoop函数，这个函数确保我们在不加锁的情况下也能保证线程安全，原因就是one loop one thread，我们将EventLoop对象与线程绑定起来了，而且一个线程只有一个EventLoop对象。runInLoop的实现非常简单，只需要传递进来需要执行的任务，这个任务其实就是一个执行函数，比如新增定时器函数、刷新定时任务函数、取消定时任务函数等等。runInLoop函数首先会判断当前执行的线程是否是EventLoop对象绑定的线程，如果是的话，就直接执行这个任务，如果不是的话就不能执行，不能让其它线程执行这个任务，否则会线程不安全，所以只能将其加入到任务池中等待执行。

    // 用于判断当前线程是否是EventLoop对应的线程
    bool isInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }
    
    // 判断将要执行的任务是否在当前线程中，如果是则执行，如果不是则压入任务队列
    void runInLoop(const Functor &callBack)
    {
        if (isInLoop())
        {
            callBack();
            return;
        }
        pushTaskQueue(callBack);
    }

将任务加入到任务池之后，前面说了，为了防止连接没有发送数据而导致线程阻塞等待在epoll_wait处，所以需要利用eventfd立即唤醒线程。

    void weakupEventFd()
    {
        uint64_t val = 1;
        // 向eventfd文件描述符中写入数据，写入的数据也不重要
        // 因为这个文件描述符已经被epoll监控起来了
        // 只要有数据到来就会触发可读事件，那epoll_wait就不会阻塞了
        // 这样就可以唤醒可能因为没有事件就绪而阻塞的线程
        int writeRes = write(_event_fd, &val, sizeof(val));
        if (writeRes < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG("write eventfd error");
            abort();
        }
    }

    // 将任务压入任务队列
    void pushTaskQueue(const Functor &callBack)
    {
        // 这里需要加锁保护_tasks的插入
        // 因为_tasks是临界资源，这里有可能会出现当前线程
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(callBack);
        }
        weakupEventFd();
    }

这就是runInLoop函数的逻辑，接下来介绍EventLoop另一个很重要的函数接口，这个接口就是外部通过EventLoop启动事件监控的接口，该接口的实现是，首先调用Poller的poll函数启动事件监控，这个函数会返回所有触发事件的Channel对象，通过这个Channel对象去调用handlerEvent函数，就能调用触发事件对应的回调函数。最后再执行任务池里的所有函数即可。

    // 事件监控->就绪事件处理->执行任务
    void start()
    {
        while (true)
        {
            std::vector<Channel *> actives;
            _poller.poll(&actives);
            for (auto &channel : actives)
            {
                channel->handlerEvent();
            }
            runAllTasks();
        }
    }

那么Poller里监控的事件是什么事件呢？是由谁设置的事件呢？所以EventLoop还有两个接口是updateEvent和removeEvent，分别用来更新事件和移除事件，外部需要构造一个Channel对象，通过这两个接口来向Poller的epoll模型更新或者删除事件监控。

    // 添加/修改描述符的事件监控
    void updateEvent(Channel *channel)
    {
        _poller.updateEvent(channel);
    }

    // 移除描述符的监控
    void removeEvent(Channel *channel)
    {
        _poller.removeEvent(channel);
    }

至此，EventLoop与底层各个关联模块的逻辑就理清楚了，这里可以直接给出EventLoop的完整代码：

/// @brief 这是封装reactor操作的类，服务器实现的是多reactor多线程的IO模型
class EventLoop
{
public:
    void readEventFd()
    {
        uint64_t res = 0;
        // 将eventfd文件描述符的数据读取处理
        // 读取到的数据我们并不关心，因为eventfd是为了唤醒可能因为没有事件就绪而阻塞在epoll_wait函数调用的线程
        int readRes = read(_event_fd, &res, sizeof(res));
        if (readRes < 0)
        {
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LOG("read eventfd error");
            abort();
        }
    }

    EventLoop()
        : _thread_id(std::this_thread::get_id()),
          _event_fd(createEventFd()),
          _event_channel(new Channel(this, _event_fd)),
          _timerWheel(this)
    {
        // 初始化eventfd文件描述符的可读事件回调函数，设置为readEventFd
        _event_channel->setReadAbleCallBack(std::bind(&EventLoop::readEventFd, this));
        // 开启可读事件监控
        _event_channel->startReadAbleEvent();
    }

    static int createEventFd()
    {
        // 创建eventfd文件描述符，将该文件描述符设置为非阻塞
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            LOG("eventfd error");
            abort();
        }
        return efd;
    }

    void weakupEventFd()
    {
        uint64_t val = 1;
        // 向eventfd文件描述符中写入数据，写入的数据也不重要
        // 因为这个文件描述符已经被epoll监控起来了
        // 只要有数据到来就会触发可读事件，那epoll_wait就不会阻塞了
        // 这样就可以唤醒可能因为没有事件就绪而阻塞的线程
        int writeRes = write(_event_fd, &val, sizeof(val));
        if (writeRes < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG("write eventfd error");
            abort();
        }
    }

    // 断言当前线程是否是eventLoop对应的线程
    // 因为很多函数会触及对临界资源的修改，如果多线程去调用的话是会有线程安全问题的
    // 可以加锁解决，但是加锁会很消耗资源，影响效率
    // 所以使用将每一个eventLoop的操作都放在一个线程里，如果不是该线程就不能调用该eventLoop对象的函数
    // 这样就不会有线程安全的问题了
    void assertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }

    // 判断将要执行的任务是否在当前线程中，如果是则执行，如果不是则压入任务队列
    void runInLoop(const Functor &callBack)
    {
        if (isInLoop())
        {
            callBack();
            return;
        }
        pushTaskQueue(callBack);
    }

    // 将任务压入任务队列
    void pushTaskQueue(const Functor &callBack)
    {
        // 这里需要加锁保护_tasks的插入
        // 因为_tasks是临界资源，这里有可能会出现当前线程
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(callBack);
        }
        weakupEventFd();
    }

    // 用于判断当前线程是否是EventLoop对应的线程
    bool isInLoop()
    {
        return (_thread_id == std::this_thread::get_id());
    }

    // 添加/修改描述符的事件监控
    void updateEvent(Channel *channel)
    {
        _poller.updateEvent(channel);
    }

    // 移除描述符的监控
    void removeEvent(Channel *channel)
    {
        _poller.removeEvent(channel);
    }

    // 执行所有任务池中的任务
    void runAllTasks()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for (auto &f : functor)
        {
            f();
        }
    }

    // 事件监控->就绪事件处理->执行任务
    void start()
    {
        while (true)
        {
            std::vector<Channel *> actives;
            _poller.poll(&actives);
            for (auto &channel : actives)
            {
                channel->handlerEvent();
            }
            runAllTasks();
        }
    }

    void addTimer(uint64_t id, uint32_t delay, const TaskFunc &task)
    {
        _timerWheel.addTimer(id, delay, task);
    }

    void refreshTimer(uint64_t id)
    {
        _timerWheel.refreshTimer(id);
    }

    void cancelTimer(uint64_t id)
    {
        _timerWheel.cancelTimer(id);
    }

    bool hasTimer(uint64_t id)
    {
        return _timerWheel.hasTimer(id);
    }

private:
    std::thread::id _thread_id;              // 线程ID
    int _event_fd;                           // eventfd唤醒IO事件监控有可能导致的阻塞
    Poller _poller;                          // 进行所有描述符的事件监控
    std::vector<Functor> _tasks;             // 任务池
    std::mutex _mutex;                       // 实现任务池操作的线程安全
    std::unique_ptr<Channel> _event_channel; // 这是管理eventfd的Channel对象
    TimerWheel _timerWheel;
};