一：事件循环池类

事件循环池是一个单例类，管理着EventPoller

1、EventPollerPool构造函数

EventPollerPool::EventPollerPool() {
    auto size = addPoller("event poller", s_pool_size, ThreadPool::PRIORITY_HIGHEST, true);
    InfoL << "创建EventPoller个数:" << size;
}

2：循环池的添加EventPoller

根据s_pool_size的大小，实例化s_pool_size个EventPoller，在调用runLoop时创建不同的线程

size_t TaskExecutorGetterImp::addPoller(const string &name, size_t size, int priority, bool register_thread) {
    auto cpus = thread::hardware_concurrency();
    size = size > 0 ? size : cpus;
    for (size_t i = 0; i < size; ++i) {
        EventPoller::Ptr poller(new EventPoller((ThreadPool::Priority) priority));
        poller->runLoop(false, register_thread);//这里创建不同的线程
        auto full_name = name + " " + to_string(i);
        poller->async([i, cpus, full_name]() {
            setThreadName(full_name.data());
            setThreadAffinity(i % cpus);
        });
        _threads.emplace_back(std::move(poller));
    }
    return size;
}

在调用runLoop时blocked传递的为false，因此是在函数else分支创建的线程，然后将runLoop函数传入线程，并将参数blocked 修改为true,
这样创建了不同的线程执行runLoop，事件循环以多路复用epoll的模型建立轮巡过程，epoll原理不在多描述

void EventPoller::runLoop(bool blocked,bool regist_self) {
    if (blocked) {
       	......
    } else {
        _loop_thread = new thread(&EventPoller::runLoop, this, true, regist_self);
        _sem_run_started.wait();
    }
}

二：EventPoller（事件轮巡）

通过epoll监听2种类型文件描述符

1、socket的描述符，主要是监听不同客户端发来的数据

通过addEvent将需要监听的fd加入epoll管理，
如果是当前线程，则将事件加入_event_map去管理当epoll事件触发时，又会将事件epoll触发事件回调出去，也就是传入的PollEventCB
如果不是当前线程，异步处理，其实就是利用管道将事件在当前线程处理，管道处理过程可以操控2

int EventPoller::addEvent(int fd, int event, PollEventCB cb) {
    TimeTicker();
    if (!cb) {
        WarnL << "PollEventCB 为空!";
        return -1;
    }

    if (isCurrentThread()) {
        struct epoll_event ev = {0};
        ev.events = (toEpoll(event)) | EPOLLEXCLUSIVE;
        ev.data.fd = fd;
        int ret = epoll_ctl(_epoll_fd, EPOLL_CTL_ADD, fd, &ev);
        if (ret == 0) {
            _event_map.emplace(fd, std::make_shared<PollEventCB>(std::move(cb)));
        }
        return ret;
    }

    async([this, fd, event, cb]() {
        addEvent(fd, event, std::move(const_cast<PollEventCB &>(cb)));
    });
    return 0;
}

2、内部的自定义事件，利用linux管道模拟文件，从而进行监听，

程序对管道进行了包装，同时在构造函数中构建了管道

PipeWrap _pipe;
PipeWrap::PipeWrap(){
	//创建管道
    if (pipe(_pipe_fd) == -1) {
        throw runtime_error(StrPrinter << "create posix pipe failed:" << get_uv_errmsg());\
    }
    SockUtil::setNoBlocked(_pipe_fd[0],true);
    SockUtil::setNoBlocked(_pipe_fd[1],false);
    SockUtil::setCloExec(_pipe_fd[0]);
    SockUtil::setCloExec(_pipe_fd[1]);
}

在EventPoller构造的时候，就已经将管道加入了epoll管理，并且回调为onPipeEvent

EventPoller::EventPoller(ThreadPool::Priority priority ) {
	......
    //添加内部管道事件
    if (addEvent(_pipe.readFD(), Event_Read, [this](int event) { onPipeEvent(); }) == -1) {
        throw std::runtime_error("epoll添加管道失败");
    }
}

onPipeEvent定义如下，当触发时，会将_list_task交换到一个临时变量中，然后执行其中的任务，本质是处理异步任务的：在其他线程将任务添加进任务列表，同时写管道，epoll会在本线程监听到该管道的读事件，再从任务列表中取出任务去执行。从而达到异步处理任务的目的

inline void EventPoller::onPipeEvent() {
    TimeTicker();
    char buf[1024];
    int err = 0;
    do {
        if (_pipe.read(buf, sizeof(buf)) > 0) {
            continue;
        }
        err = get_uv_error(true);
    } while (err != UV_EAGAIN);

    decltype(_list_task) _list_swap;
    {
        lock_guard<mutex> lck(_mtx_task);
        _list_swap.swap(_list_task);
    }

    _list_swap.for_each([&](const Task::Ptr &task) {
        try {
            (*task)();
        } catch (ExitException &) {
            _exit_flag = true;
        } catch (std::exception &ex) {
            ErrorL << "EventPoller执行异步任务捕获到异常:" << ex.what();
        }
    });
}

三：总结

程序启动会创建一个事件循环池，大小可以自定义，默认根据硬件性能自动分配，每个事件循环类拥有自己的独立的线程，事件循环是通过多路复用epoll模式去实现，监听sock的事件接收网络数据，监听管道的事件执行异步任务