{"id":81764,"date":"2026-07-25T04:18:49","date_gmt":"2026-07-24T20:18:49","guid":{"rendered":"https:\/\/www.wsisp.com\/helps\/81764.html"},"modified":"2026-07-25T04:18:49","modified_gmt":"2026-07-24T20:18:49","slug":"%e4%bb%8e%e9%9b%b6%e6%9e%84%e5%bb%ba%e9%ab%98%e6%80%a7%e8%83%bd-reactor-%e6%9c%8d%e5%8a%a1%e5%99%a8%ef%bc%9a","status":"publish","type":"post","link":"https:\/\/www.wsisp.com\/helps\/81764.html","title":{"rendered":"\u4ece\u96f6\u6784\u5efa\u9ad8\u6027\u80fd Reactor \u670d\u52a1\u5668\uff1a"},"content":{"rendered":"

\u5f15\u8a00<\/h3>\n

\u5728\u9ad8\u5e76\u53d1\u7f51\u7edc\u7f16\u7a0b\u9886\u57df，Reactor \u6a21\u578b\u51ed\u501f\u5176\u9ad8\u6548\u7684\u4e8b\u4ef6\u9a71\u52a8\u673a\u5236，\u6210\u4e3a\u6784\u5efa\u9ad8\u6027\u80fd\u670d\u52a1\u5668\u7684\u9996\u9009\u65b9\u6848\u3002\u672c\u6587\u5c06\u4ece\u96f6\u5f00\u59cb，\u8be6\u7ec6\u5256\u6790\u4e00\u4e2a\u57fa\u4e8e\u00a0one loop per thread\u00a0\u67b6\u6784\u7684 C++ TCP Echo \u670d\u52a1\u5668\u7684\u5b9e\u73b0\u3002\u8be5\u670d\u52a1\u5668\u53c2\u8003\u4e86 muduo \u7f51\u7edc\u5e93\u7684\u8bbe\u8ba1\u601d\u60f3，\u652f\u6301\u591a\u6838\u6269\u5c55\u3001\u975e\u963b\u585e I\/O\u3001ET \u6a21\u5f0f，\u5e76\u91c7\u7528\u5f02\u6b65\u65e5\u5fd7\u548c\u65e0\u9501\u961f\u5217\u8fdb\u884c\u4f18\u5316\u3002\u6700\u7ec8\u5b9e\u73b0\u4e86\u4e00\u4e2a\u53ef\u652f\u6491\u6570\u6570\u4e07\u5e76\u53d1\u8fde\u63a5(\u53d6\u51b3\u4e8e\u786c\u4ef6\u914d\u7f6e)\u7684\u9ad8\u6027\u80fd Echo \u670d\u52a1\u3002<\/p>\n

\u8be5\u670d\u52a1\u5668\u4e3aAeroChat(\u9ad8\u6027\u80fd\u804a\u5929\u5ba4)\u7684\u7f51\u7edc\u90e8\u5206，\u6211\u5265\u79bb\u51fa\u6765\u8fdb\u884c\u4e86\u538b\u6d4b\u3002\u9879\u76ee\u4ee3\u7801\u5f00\u6e90\u5728AeroChat\/benchmark at master \u00b7 ywx914705\/AeroChat<\/span>https:\/\/github.com\/ywx914705\/AeroChat\/tree\/master\/benchmark<\/span><\/span>，\u8fd9\u4e2a\u9879\u76ee\u53ea\u5305\u542b\u4e86\u7f51\u7edc\u5c42\u6b21，\u4e0d\u6d89\u53ca\u4efb\u4f55\u4e1a\u52a1\u5c42\u6b21\u3002<\/p>\n

\u4e00\u3001\u670d\u52a1\u5668\u67b6\u6784：<\/h2>\n

\"\"<\/p>\n

\u670d\u52a1\u5668\u91c7\u7528\u00a0\u4e3b\u4ece Reactor \u591a\u7ebf\u7a0b\u6a21\u578b：<\/p>\n

\u4e3bReactor：\u4e00\u4e2aEventLoop\u7ebf\u7a0b,\u8d1f\u8d23\u76d1\u542clistenFd_\u4e0a\u7684\u65b0\u8fde\u63a5\u4e8b\u4ef6\u3002<\/p>\n

\u4ece\/\u5b50Reactor:\u591a\u4e2aEventLoop,\u6bcf\u4e2a\u7ebf\u7a0b\u8d1f\u8d23\u8fd0\u884c\u4e00\u4e2aEventLoop，\u8d1f\u8d23\u5df2\u8fde\u63a5\u7684socket\u7684I\/O\u8bfb\u5199\u3002<\/p>\n

\u901a\u8fc7\u8d1f\u8f7d\u5747\u8861\u7684\u65b9\u5f0f，\u65b0\u8fde\u63a5\u901a\u8fc7round-robin\u7b97\u6cd5\u5206\u914d\u5230\u67d0\u4e2aSubReactor\/\u5b50Reactor，\u8fde\u63a5\u4e00\u65e6\u5206\u914d\u4fbf\u56fa\u5b9a\u5728\u8be5\u7ebf\u7a0b，\u8fd9\u6837\u505a\u7684\u597d\u5904\u5c31\u662f\u4e0d\u9700\u8981\u9501\u540c\u6b65，\u5929\u7136\u7ebf\u7a0b\u5b89\u5168！<\/p>\n

\u8de8\u7ebf\u7a0b\u4efb\u52a1:\u901a\u8fc7RunInLoop\/queueInLoop+eventfd\u5b9e\u73b0\u7ebf\u7a0b\u5b89\u5168\u7684\u4efb\u52a1\u6295\u9012\u3002<\/p>\n

\u4e8c\u3001\u6838\u5fc3\u7ec4\u4ef6\u89e3\u6790:<\/h2>\n

\u7531\u4e8e\u7bc7\u5e45\u6709\u9650，\u4ee5\u4e0b\u6240\u6709\u7c7b\u53ea\u5217\u4e3e\u51fa\u90e8\u5206\u6e90\u7801，\u8be6\u7ec6\u6e90\u7801\u53ef\u53bb\u8fd9\u91cc\u67e5\u770b：AeroChat\/benchmark at master \u00b7 ywx914705\/AeroChat<\/span>https:\/\/github.com\/ywx914705\/AeroChat\/tree\/master\/benchmark<\/span><\/span><\/p>\n

1\u3001noncopyable\u7c7b:<\/h3>\n

#pragma once
\n\/\/ \u7981\u6b62\u62f7\u8d1d\u7684\u57fa\u7c7b（\u53c2\u8003\u4e86Muduo\u6838\u5fc3\u8bbe\u8ba1，\u907f\u514d\u6d45\u62f7\u8d1d\u8d44\u6e90\u9519\u8bef）
\n\/*
\n\u4f5c\u4e3a\u4e00\u4e2a\u57fa\u7c7b,\u4efb\u4f55\u7ee7\u627f\u81eanoncopyable\u7684\u7c7b\u90fd\u65e0\u6cd5\u88ab\u62f7\u8d1d\u6784\u9020\u4e0e\u62f7\u8d1d\u590d\u5236,\u8fd9\u662f\u4e3a\u4e86\u9632\u6b62\u90a3\u4e9b\u62e5\u6709\u8d44\u6e90\u7684
\n\u5bf9\u8c61\u88ab\u9519\u8bef\u62f7\u8d1d,\u8fdb\u800c\u53d1\u751f\u6790\u6784\u65f6\u91cd\u590d\u91ca\u653e\u7684\u9519\u8bef
\n\u6b21\u670d\u52a1\u5668\u4e2d\u5927\u90e8\u5206\u7684\u7c7b\u90fd\u57fa\u5c42\u81eanoncopyable(\u4e0d\u5f97\u62f7\u8d1d)
\n*\/
\nclass noncopyable {
\nprotected:
\n noncopyable() = default;
\n ~noncopyable() = default;
\n noncopyable(const noncopyable&) = delete;
\n noncopyable& operator=(const noncopyable&) = delete;
\n}; <\/p>\n

2\u3001Thread\u7c7b:<\/h3>\n

Thread\u7c7b\u7684\u4e3b\u8981\u5de5\u4f5c\u5c31\u662f\u4f7f\u7528c++11\u7684thread\u5e93\u5bf9linux\u539f\u751f\u63a5\u53e3\u8fdb\u884c\u5c01\u88c5:<\/p>\n

\/*
\n\u8be5\u6587\u4ef6\u672c\u8d28\u4e0a\u5c31\u662f\u5bf9linux posix\u7ebf\u7a0b\u7684\u5c01\u88c5(pthread_create\u521b\u5efa\u51fa\u6765\u7684\u7ebf\u7a0b)
\n\u8fd9\u4e2a\u7c7b\u5728\u6574\u4e2a\u9879\u76ee\u4e2d\u4f5c\u4e3a\u57fa\u7840\u7ec4\u4ef6,\u88abEventLoopThread\u7b49\u4e0a\u5c42\u7c7b\u4f7f\u7528
\nlinux\u4e2dposix\u5e38\u7528\u51fd\u6570:
\npthread_create() pthread_join()
\n\u6838\u5fc3\u4f18\u52bf:\u652f\u6301CPU\u4eb2\u548c\u6027,\u53ef\u4ee5\u5c06\u7ebf\u7a0b\u7ed1\u5b9a\u5230\u6307\u5b9aCPU\u6838\u5fc3,\u4f18\u5316\u6027\u80fd
\n\u4e0d\u53ef\u62f7\u8d1d:\u8be5AeroChat\u4e2d\u7edd\u5927\u591a\u6570\u7684\u7c7b\u90fd\u7ee7\u627f\u81eanocopyable,\u4e0d\u652f\u6301\u62f7\u8d1d，\u9632\u6b62\u591a\u4e2a\u5bf9\u8c61\u7ba1\u7406\u540c\u4e00\u4e2a\u7ebf\u7a0b
\n,\u907f\u514d\u8d44\u6e90\u88ab\u91cd\u590d\u91ca\u653e
\n\u8fd9\u4e2a\u7c7b\u7684\u53ef\u8bfb\u6027\u5f88\u9ad8,\u57fa\u672c\u4e0a\u770b\u5230\u51fd\u6570\/\u53d8\u91cf\u540d\u5c31\u80fd\u77e5\u9053\u5b83\u7684\u529f\u80fd\/\u4f5c\u7528
\n*\/
\n#pragma once
\n#include "noncopyable.hpp"
\n#include <pthread.h>
\n#include <functional>
\n#include <string>
\n#include <atomic>
\n#include <iostream>
\n#include <sched.h>\/\/\u7ed1CPU\u6838\u5fc3\u6240\u9700\u5934\u6587\u4ef6<\/p>\n

class Thread : noncopyable {
\npublic:
\n using ThreadFunc = std::function<void()>;<\/p>\n

explicit Thread(ThreadFunc func, const std::string& name = "Thread");
\n ~Thread();<\/p>\n

void start();
\n void join();\/\/\u5e95\u5c42\u8c03\u7528pthread_join()
\n void bindCurrentThreadToCore(int coreId);
\n \/\/\u76ee\u7684\u662f\u8ba9\u5f53\u524d\u8c03\u7528\u5b83\u7684\u7ebf\u7a0b\u7ed1\u5b9a\u5230\u6307\u5b9a\u6838\u5fc3\u3002\u901a\u5e38\u6211\u4eec\u5728\u5b50\u7ebf\u7a0b\u5185\u90e8\u8c03\u7528\u5b83，
\n \/\/\u5c06\u81ea\u5df1\u7ed1\u5b9a\u5230\u9884\u5148\u8bbe\u5b9a\u7684\u6838\u5fc3\u3002<\/p>\n

void setCoreAffinity(int coreId) { coreId_ = coreId; }
\n \/\/\u8bbe\u7f6e\u6210\u5458coureId_,\u8bb0\u5f55\u5e0c\u671b\u7ed1\u5b9a\u7684\u7ebf\u7a0b\u6838\u5fc3\u53f7,\u5b9e\u9645\u7ed1\u5b9a\u53d1\u751f\u5728\u7ebf\u7a0b\u542f\u52a8\u540e<\/p>\n

pthread_t tid() const { return tid_; }
\n const std::string& name() const { return name_; }
\n static int numCreated() { return numCreated_.load(); }<\/p>\n

private:
\n static void* runInThread(void* arg);<\/p>\n

ThreadFunc func_;\/\/\u7ebf\u7a0b\u51fd\u6570
\n std::string name_;\/\/\u7ebf\u7a0b\u540d\u5b57,\u7528\u4e8e\u65e5\u5fd7\u6807\u8bc6
\n pthread_t tid_;\/\/\u7ebf\u7a0bID
\n bool started_;\/\/bool\u7c7b\u578b,\u8868\u793a\u7ebf\u7a0b\u662f\u5426\u542f\u52a8 ture:\u542f\u52a8\u4e86 false:\u6ca1\u6709\u542f\u52a8
\n bool joined_;\/\/\u662f\u5426\u8c03\u7528join(\u662f\u5426\u8c03\u7528linux\u4e2d\u7684pthrea_join()\u51fd\u6570)
\n static std::atomic_int numCreated_;\/\/\u5df2\u7ecf\u521b\u5efa\u7ebf\u7a0b\u7684\u6570\u91cf,\u9759\u6001\u539f\u5b50\u53d8\u91cf<\/p>\n

int coreId_ = -1;\/\/\u671f\u671b\u7ed1\u5b9a\u7684 CPU \u6838\u5fc3\u7f16\u53f7，-1 \u8868\u793a\u4e0d\u7ed1\u5b9a
\n}; <\/p>\n

3\u3001Channel(I\/O \u4e8b\u4ef6\u5206\u53d1\u5668)：<\/h3>\n

Channel\u5305\u542b\u4e86\u5bf9fd\u7684\u6240\u6709\u5c01\u88c5，\u4e00\u4e2achannel\u5bf9\u5e94\u4e00\u4e2afd\u3002<\/p>\n

Channel\u7684\u6210\u5458\u53d8\u91cf:<\/p>\n

EventLoop* loop_;\/\/\u6240\u5c5e\u7684\u4e8b\u4ef6\u5faa\u73af
\n const int fd_;\/\/\u6587\u4ef6\u63cf\u8ff0\u7b26
\n uint32_t events_;\/\/\u5f53\u524d\u5173\u6ce8\u7684\u4e8b\u4ef6(\u5982EPOLLIN\/EPOLLOUT\/EPOLLET)
\n uint32_t revents_;\/\/epoll_wait\u6240\u8fd4\u56de\u5b9e\u9645\u53d1\u751f\u7684\u4e8b\u4ef6
\n int index_;\/\/\u5728Poller\u4e2d\u7684\u72b6\u6001(kNew\/kAdded\/kDeleted)
\n \/\/\u8bfb\u3001\u5199\u3001\u5173\u95ed\u3001\u9519\u8bef\u5bf9\u5e94\u7684\u4e8b\u4ef6\u56de\u8c03 \u56de\u8c03\u51fd\u6570:\u7528\u6237\u6ce8\u518c\u7684\u4e1a\u52a1\u5904\u7406\u51fd\u6570,\u5f53\u5bf9\u5e94\u4e8b\u4ef6\u53d1\u751f\u65f6\u88ab\u8c03\u7528
\n EventCallback readCallback_;
\n EventCallback writeCallback_;
\n EventCallback closeCallback_;
\n EventCallback errorCallback_; <\/p>\n

Channel\u7684\u6210\u5458\u65b9\u6cd5:<\/p>\n

void Channel::handleEvent() { \/\/\u8be5\u51fd\u6570\u7531EventLoop::loop()\u6536\u5230epoll\u4e8b\u4ef6\u540e\u8fdb\u884c\u8c03\u7528,\u4e14\u6267\u884c\u5728\u6240\u5c5e\u7684
\n\/\/EventLoop\u7ebf\u7a0b\u4e2d,\u4fdd\u8bc1\u4e86\u7ebf\u7a0b\u5b89\u5168
\n if (revents_ & (EPOLLRDHUP | EPOLLHUP)) { \/\/\u5982\u679c\u5bf9\u7aef\u5173\u95ed\u8fde\u63a5\u6216\u8005\u6302\u8d77,\u6b64\u65f6\u8fde\u63a5\u4e0d\u53ef\u7528,\u76f4\u63a5\u5173\u95ed
\n LOG_WARN("[Channel] FD " + std::to_string(fd_) + " \u5ba2\u6237\u7aef\u5173\u95ed\u8fde\u63a5");
\n if (closeCallback_) closeCallback_();
\n return;
\n }
\n if (revents_ & EPOLLERR) {
\n LOG_ERROR("[Channel] FD " + std::to_string(fd_) + " \u53d1\u751f\u9519\u8bef");
\n if (errorCallback_) errorCallback_();
\n }
\n if (revents_ & (EPOLLIN | EPOLLPRI)) {
\n if (readCallback_) readCallback_();
\n }
\n if (revents_ & EPOLLOUT) {
\n if (writeCallback_) writeCallback_();
\n }
\n}<\/p>\n

\/\/\u901a\u77e5EventLoop\u8fdb\u884c\u66f4\u65b0 Channel\u4e0d\u76f4\u63a5\u64cd\u4f5cepoll,\u800c\u662f\u901a\u8fc7EventLoop\u7edf\u4e00\u7ba1\u7406
\nvoid Channel::update() {
\n loop_->updateChannel(this);
\n}<\/p>\n

\u4e3a\u4ec0\u4e48\u8981\u6709Channel?<\/p>\n

Channel \u4e0d\u76f4\u63a5\u64cd\u4f5c epoll，\u800c\u662f\u901a\u8fc7\u00a0EventLoop\u00a0\u95f4\u63a5\u8c03\u7528\u00a0Poller，\u5b9e\u73b0\u89e3\u8026\u3002\u5982\u679c\u5bf9Poller\u548cEventLoop\u4e0d\u662f\u5f88\u4e86\u89e3\u53ef\u4ee5\u7ee7\u7eed\u5f80\u4e0b\u770b<\/p>\n

4\u3001Poller：<\/h3>\n

Poller.hpp<\/p>\n

\/*
\nPoller:\u6bcf\u4e2aEventLoop\u62e5\u6709\u4e00\u4e2aPoller\u5bf9\u8c61(\u4e00\u4e00\u5bf9\u5e94),\u8d1f\u8d23\u5b9e\u9645\u7684epoll\u64cd\u4f5c,EventLoop\u901a\u8fc7updateChannel
\n\u5c06Channel\u7684\u53d8\u5316\u540c\u6b65\u5230Poller,\u5e76\u5728\u6bcf\u6b21\u5faa\u73af\u4e2d\u8c03\u7528poll\u83b7\u53d6\u6d3b\u8dc3\u7684Channel,\u7136\u540e\u8c03\u7528\u5b83\u4eec\u7684handleEvent
\n*\/
\n#pragma once
\n#include "noncopyable.hpp"
\n#include <sys\/epoll.h>
\n#include <unordered_map>
\n#include <vector>
\n\/\/ \u524d\u7f6e\u58f0\u660e
\nclass EventLoop;
\nclass Channel;<\/p>\n

class Poller : noncopyable {
\npublic:
\n explicit Poller(EventLoop *loop);
\n ~Poller() = default;<\/p>\n

void poll(int timeoutMs, std::vector<Channel *> *activeChannels);
\n void updateChannel(Channel *channel);
\n void removeChannel(Channel *channel);<\/p>\n

private:
\n void fillActiveChannels(int numEvents,
\n std::vector<Channel *> *activeChannels) const;<\/p>\n

EventLoop *ownerLoop_; \/\/ \u5bf9\u5e94\u7684EventLoop
\n int epollfd_; \/\/ epoll_create1()\u521b\u5efa\u51fa\u6765\u7684df
\n std::unordered_map<int, Channel *> channels_; \/\/ fd\u4e0eChannel\u7684\u6620\u5c04\u5173\u7cfb
\n std::vector<struct epoll_event> events_; \/\/ \u7528\u4e8e epoll_wait \u7684\u4e8b\u4ef6\u6570\u7ec4
\n}; <\/p>\n

Poller\u53ea\u6709\u56db\u4e2a\u6210\u5458\u53d8\u91cf，\u5206\u522b\u662fownerLoop_\u3001epoolfd\u3001channels\u3001events_，\u90a3\u4e48\u5206\u522b\u90fd\u662f\u4ec0\u4e48\u610f\u601d\u5462？<\/p>\n

1\u3001ownerLoop_\u8868\u793a\u7684\u662fEventLoop\u5bf9\u5e94\u7684\u6307\u9488，\u4e00\u4e2aPoller\u5bf9\u5e94\u4e00\u4e2aEventLoop,Poller\u548cEventLoop\u662f\u4e00\u4e00\u5bf9\u5e94\u7684\u5173\u7cfb，\u6240\u4ee5Poller\u5fc5\u987b\u5f97\u6709EventLoop\u7684\u6307\u9488，\u95f4\u63a5\u5730\u6807\u5fd7\u4e86\u8be5Poller\u662f\u4e0e\u54ea\u4e00\u4e2aEventLoop\u5bf9\u5e94\u7684\u3002<\/p>\n

2\u3001epollfd，\u8fd9\u4e2a\u53ea\u8981\u662f\u7528\u8fc7epoll\u7684\u670b\u53cb\u90fd\u5e94\u8be5\u5f88\u719f\u6089，epoll\u6709\u4e09\u4e2a\u5e38\u7528\u7684\u63a5\u53e3，\u5206\u522b\u662fepoll_create(int size)，epoll_ctl()，epoll_wait()，\u800c\u8fd9\u4e2aepollfd\u5c31\u662f\u7531epoll_create\/epoll_create1\u6240\u8fd4\u56de\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26\u4e5f\u5c31\u662ffd，epoll_create1\u662f\u65b0\u63a5\u53e3,\u53c2\u6570\u4e3aint flag，\u8fd9\u4e2aflag\u7528\u6765\u63a7\u5236\u884c\u4e3a，\u800c\u539f\u63a5\u53e3\u7684size\u5df2\u7ecf\u88ab\u5185\u6838\u6240\u5ffd\u7565\u3002<\/p>\n

3\u3001unordered\u662fSTL\u7684\u5e38\u7528\u5bb9\u5668，\u662f\u4e00\u4e2aKV\u7684\u5b58\u50a8\u7ed3\u6784，\u5e95\u5c42\u662f\u54c8\u5e0c\u8868，\u4e3a\u4ec0\u4e48\u8981\u7528\u8fd9\u4e2a\u5462？\u7528\u6765\u5b58\u50a8\u6240\u6709\u7684\u952e\u503c\u5bf9，\u4e0a\u9762\u8bf4\u4e86，Channel\u662f\u5bf9fd\u7684\u4e00\u4e2a\u5c01\u88c5，fd\u4e0echannel\u662f\u4e00\u4e00\u5bf9\u5e94\u7684\u5173\u7cfb，\u4e00\u4e2afd\u5bf9\u5e94\u4e00\u4e2aChannel，\u800c\u8fd9\u4e2achannels_\u5b58\u50a8\u4e86\u6240\u6709\u7684\u952e\u503c\u5bf9\u4e5f\u5c31\u662f\u6620\u5c04\u5173\u7cfb\u3002\u540e\u7eed\u5c31\u53ef\u4ee5\u901a\u8fc7\u67e5\u627echannels_\u627e\u5230\u5bf9\u5e94fd\u6240\u5bf9\u5e94\u7684Channel\u4e86\u3002<\/p>\n

4\u3001events_，\u7528\u4e8e\u5b58\u50a8epoll_wait\u5c31\u7eea\u4e8b\u4ef6\u7684\u6570\u7ec4，EventLoop\u4f1a\u904d\u5386\u8fd9\u4e2a\u6570\u7ec4，\u627e\u5230\u5df2\u7ecf\u5c31\u7eea\u7684\u4e8b\u4ef6，\u7136\u540e\u901a\u8fc7channels_\u627e\u5230\u5bf9\u5e94\u7684Channel，\u7136\u540e\u8c03\u7528\u5176\u56de\u8c03\u51fd\u6570\u5904\u7406\u8bfb\u5199\u7b49\u903b\u8f91<\/p>\n

5\u3001EventLoop(\u4e8b\u4ef6\u5faa\u73af):<\/h3>\n

\u670d\u52a1\u5668\u7684\u6838\u5fc3，\u8be5\u670d\u52a1\u5668\u91c7\u7528\u7684\u662f\u4e3b\u4eceReactor，\u6bcf\u4e2aReactor\u90fd\u6709\u4e00\u4e2aEventLoop\u90fd\u5728\u8fd0\u884cloop()\u3002<\/p>\n

\n

\u4f20\u7edf\u670d\u52a1\u5668\u7684\u672c\u8d28\u90fd\u662f\u5728\u6267\u884c\u4e00\u4e2a while \u5faa\u73af，\u4e0d\u65ad\u76d1\u542c\u3001\u5206\u53d1\u5e76\u5904\u7406 IO \u4e8b\u4ef6，\u800c\u8fd9\u91cc\u7684 EventLoop \u5c31\u76f8\u5f53\u4e8e\u5bf9\u8fd9\u5957\u5faa\u73af\u7684\u9ad8\u5ea6\u5c01\u88c5\u3002\u6240\u8c13\u4e3b\u4ece Reactor \u672c\u8d28\u5c31\u662f：MainReactor \u6267\u884c handleAccept() \u63a5\u6536\u65b0\u8fde\u63a5，\u76f8\u5f53\u4e8e\u4f20\u7edf\u670d\u52a1\u5668\u4e2d\u8c03\u7528 accept() \u8fd9\u4e2a\u51fd\u6570\u3002\u7136\u800c，\u4e0e\u5355\u7ebf\u7a0b\u670d\u52a1\u5668\u4e0d\u540c\u7684\u662f，MainReactor \u5e76\u4e0d\u8d1f\u8d23\u540e\u7eed\u7684\u8bfb\u5199 IO，\u800c\u662f\u5c06\u65b0\u5efa\u7acb\u7684\u8fde\u63a5\u901a\u8fc7\u8d1f\u8f7d\u5747\u8861\u7b56\u7565，\u5206\u53d1\u7ed9\u67d0\u4e2a SubReactor \u53bb\u76d1\u542c\u4e0e\u7ba1\u7406，\u5728\u8fd9\u4e2a\u670d\u52a1\u5668\u91cc\u5c31\u662f\u8c03\u7528handleNewConnection()\u51fd\u6570，\u8fd9\u4e5f\u5c31\u662f\u4e3a\u4ec0\u4e48\u6709\u4e86handleAccept()\u4e86\u8fd8\u8981\u6709handleNewConnection()\u3002<\/span>\u6bcf\u4e2a SubReactor \u62e5\u6709\u72ec\u7acb\u7684 EventLoop \u548c epoll \u5b9e\u4f8b，\u8d1f\u8d23\u5bf9\u5e94\u8fde\u63a5\u7684\u53ef\u8bfb\u3001\u53ef\u5199\u4e8b\u4ef6\u5206\u53d1\u4e0e\u5904\u7406，\u5b9e\u73b0\u4e86 IO \u591a\u8def\u590d\u7528\u4e0e\u591a\u7ebf\u7a0b\u5e76\u884c\u5904\u7406，\u4ece\u800c\u5927\u5e45\u63d0\u5347\u4e86\u6027\u80fd！<\/p>\n

\u4ee5\u4e0b\u53ea\u7ed9\u51faEventLoop\u7684\u5934\u6587\u4ef6，\u5177\u4f53\u5b9e\u73b0\u53ef\u770b\u6e90\u7801:<\/p>\n

\/*
\nEventLoop\u662fAeroChat\u4e2dReactor\u6a21\u5f0f\u7684\u6838\u5fc3\u7ec4\u4ef6\u3002
\n\u6bcf\u4e2aEventLoop \u5bf9\u8c61\u7ed1\u5b9a\u4e00\u4e2a\u7ebf\u7a0b,\u5b9e\u73b0 "One Loop Per Thread" \u8bbe\u8ba1\u3002
\n\u5b83\u8d1f\u8d23：
\n\u9a71\u52a8\u4e8b\u4ef6\u5faa\u73af\u8c03\u7528Poller\u7684poll\u65b9\u6cd5\u83b7\u53d6\u6d3b\u8dc3Channel；
\n\u5206\u53d1 I\/O \u4e8b\u4ef6（\u901a\u8fc7 Channel \u7684\u56de\u8c03）
\n\u6267\u884c\u8de8\u7ebf\u7a0b\u6295\u9012\u7684\u4efb\u52a1（\u901a\u8fc7\u65e0\u9501\u961f\u5217 pendingFunctors_）\u3002
\n *\/
\n#ifndef EVENTLOOP_HPP
\n#define EVENTLOOP_HPP<\/p>\n

#include <atomic>
\n#include <functional>
\n#include <memory>
\n#include <mutex>
\n#include <thread>
\n#include <vector>
\n#include <sys\/eventfd.h> \/\/ for eventfd
\n#include <unistd.h> \/\/ for close<\/p>\n

#include "Channel.hpp"
\n#include "Poller.hpp"
\n#include "concurrentqueue.hpp"<\/p>\n

class EventLoop {
\npublic:
\n EventLoop();
\n ~EventLoop();<\/p>\n

\/\/ \u542f\u52a8\u4e8b\u4ef6\u5faa\u73af（\u963b\u585e）
\n void loop();<\/p>\n

\/\/ \u8bf7\u6c42\u9000\u51fa\u4e8b\u4ef6\u5faa\u73af
\n void quit();<\/p>\n

\/\/ \u66f4\u65b0 Channel \u5728 Poller \u4e2d\u7684\u6ce8\u518c\u72b6\u6001（\u65b0\u589e\u3001\u4fee\u6539\u6216\u5220\u9664）
\n void updateChannel(Channel *channel);
\n void removeChannel(Channel *channel);<\/p>\n

\/\/ \u8de8\u7ebf\u7a0b\u4efb\u52a1\u6295\u9012
\n void runInLoop(
\n const std::function<void()> &cb); \/\/ \u82e5\u5728\u5f53\u524d\u7ebf\u7a0b\u5219\u76f4\u63a5\u6267\u884c，\u5426\u5219\u5165\u961f
\n void queueInLoop(const std::function<void()> &cb); \/\/ \u603b\u662f\u5165\u961f<\/p>\n

\/\/ \u5224\u65ad\u8c03\u7528\u8005\u662f\u5426\u5728 EventLoop \u6240\u5c5e\u7ebf\u7a0b\u4e2d
\n bool isInLoopThread() const {
\n return threadId_ == std::this_thread::get_id();
\n }<\/p>\n

\/\/ \u7d22\u5f15（\u7528\u4e8e\u533a\u5206\u4e3b Reactor \u548c\u5b50 Reactor）
\n int getIndex() const { return index_; }
\n void setIndex(int idx) { index_ = idx; }<\/p>\n

private:
\n \/\/ \u6267\u884c\u6240\u6709\u5f85\u5904\u7406\u7684\u8de8\u7ebf\u7a0b\u56de\u8c03
\n void doPendingFunctors();<\/p>\n

\/\/ \u5524\u9192 EventLoop \u7ebf\u7a0b（\u5f53\u6709\u4efb\u52a1\u5165\u961f\u4e14\u4e0d\u5728\u672c\u7ebf\u7a0b\u65f6\u8c03\u7528）
\n void wakeup();
\n \/\/ eventfd \u8bfb\u4e8b\u4ef6\u56de\u8c03，\u7528\u4e8e\u6e05\u7a7a\u5524\u9192\u6807\u5fd7
\n void handleWakeup();<\/p>\n

std::atomic<bool> looping_; \/\/ \u662f\u5426\u6b63\u5728\u5faa\u73af
\n std::atomic<bool> quit_; \/\/ \u662f\u5426\u9000\u51fa
\n int index_; \/\/ \u6807\u8bc6（\u4e3b Reactor \u4e3a 0，\u5b50 Reactor \u4e3a 1..N）
\n std::thread::id threadId_; \/\/ \u6240\u5c5e\u7ebf\u7a0b ID
\n moodycamel::ConcurrentQueue<std::function<void()>>
\n pendingFunctors_; \/\/ \u65e0\u9501\u961f\u5217，\u5b58\u50a8\u8de8\u7ebf\u7a0b\u4efb\u52a1
\n bool callingPendingFunctors_; \/\/ \u662f\u5426\u6b63\u5728\u6267\u884c\u5f85\u5904\u7406\u56de\u8c03(\u9632\u6b62\u91cd\u5165)<\/p>\n

std::unique_ptr<Poller> poller_; \/\/ I\/O\u591a\u8def\u590d\u7528\u5668(\u5f53\u524d\u4e3aepoll)<\/p>\n

\/\/ \u5524\u9192\u673a\u5236\u76f8\u5173
\n int wakeupFd_; \/\/ eventfd \u6587\u4ef6\u63cf\u8ff0\u7b26
\n std::unique_ptr<Channel> wakeupChannel_; \/\/ \u5c01\u88c5 wakeupFd_ \u7684 Channel
\n};<\/p>\n

#endif \/\/ EVENTLOOP_HPP <\/p>\n

6\u3001EventLoopThread:<\/h3>\n

\u8fd9\u4e2a\u7c7b\u5c31\u662f\u5b9e\u73b0One Loop Per Thead\u7684\u6838\u5fc3:<\/p>\n

\/*
\none loop per thread\u7684\u5177\u4f53\u5b9e\u73b0
\nEventLoopThread\u7684\u76ee\u7684\u5c31\u662f\u5c06EventLoop\u5bf9\u8c61\u4e0e\u4e00\u4e2a\u72ec\u7acb\u7ebf\u7a0b\u7ed1\u5b9a,\u4f7f\u8be5\u7ebf\u7a0b\u8fd0\u884c\u4e8b\u4ef6\u5faa\u73af,\u5b9e\u73b0\u4e00\u4e2a\u7ebf\u7a0b
\n\u4e00\u4e2a\u4e8b\u4ef6\u5faa\u73af
\n\u8fd9\u4e2a\u7c7b\u4e3b\u8981\u8d1f\u8d23:
\n1\u3001\u521b\u5efa\u7ebf\u7a0b,\u5728\u7ebf\u7a0b\u4e2d\u6784\u9020EventLoop\u5bf9\u8c61(\u6808\u4e0a)
\n2\u3001\u542f\u52a8\u65f6\u95f4\u5faa\u73af,\u76f4\u5230\u7ebf\u7a0b\u9000\u51fa
\n3\u3001\u63d0\u4f9b\u540c\u6b65\u673a\u5236，\u786e\u4fdd\u8c03\u7528\u8005\u80fd\u83b7\u5f97\u5df2\u7ecf\u5c31\u7eea\u7684EventLoop\u6307\u9488
\nEventLoopThread\u662f\u5982\u4f55\u4e0eThread\u5efa\u7acb\u8054\u7cfb\u7684？<\/p>\n

thread_.start() \u5185\u90e8\u8c03\u7528 pthread_create(&tid_, nullptr, runInThread, this)\u3002<\/p>\n

\u65b0\u7ebf\u7a0b\u542f\u52a8\u540e,\u6267\u884c runInThread(this)\u3002<\/p>\n

runInThread\u5c06this \u8f6c\u56de Thread*\u5e76\u8c03\u7528 thread->func_(),
\n\u4e5f\u5c31\u662f\u6267\u884c EventLoopThread::threadFunc\u3002
\n\u4e8e\u662f,EventLoopThread::threadFunc\u5c31\u5728\u5b50\u7ebf\u7a0b\u4e2d\u8fd0\u884c,\u521b\u5efa\u5e76\u8fd0\u884cEventLoop\u3002<\/p>\n

*\/
\n#ifndef EVENTLOOPTHREAD_HPP
\n#define EVENTLOOPTHREAD_HPP
\n#include "Thread.hpp"
\n#include "EventLoop.hpp"
\n#include <condition_variable>
\n#include <mutex>
\n#include <string><\/p>\n

class EventLoopThread : noncopyable {
\npublic:
\n explicit EventLoopThread(const std::string& name = std::string());
\n ~EventLoopThread();<\/p>\n

EventLoop* startLoop();\/\/\u542f\u52a8\u7ebf\u7a0b,\u8fd4\u56de\u5173\u8054\u7684EventLoop\u6307\u9488<\/p>\n

private:
\n void threadFunc();\/\/\u7ebf\u7a0b\u51fd\u6570<\/p>\n

EventLoop* loop_;\/\/\u6307\u5411\u672c\u7ebf\u7a0b\u4e2d\u6240\u521b\u5efa\u7684EventLoop\u5bf9\u8c61
\n bool exiting_;\/\/\u662f\u5426\u9000\u51fa
\n Thread thread_;\/\/\u5bf9\u5e94\u7684\u7ebf\u7a0b
\n std::mutex mutex_;\/\/\u4e92\u65a5\u9501
\n std::condition_variable cond_;\/\/\u6761\u4ef6\u53d8\u91cf
\n};<\/p>\n

#endif \/\/ EVENTLOOPTHREAD_HPP<\/p>\n

\u4e3a\u4ec0\u4e48\u8bf4\u8fd9\u4e2a\u7c7b\u662f\u5b9e\u73b0One Loop Per Thread\u7684\u6838\u5fc3？\u6765\u770b\u4e00\u4e0b\u8fd9\u4e2a\u7c7b\u7684\u6210\u5458\u51fd\u6570:<\/p>\n

EventLoopThread::EventLoopThread(const std::string& name)
\n : loop_(nullptr), exiting_(false), thread_(std::bind(&EventLoopThread::threadFunc, this), name) {}
\n \/\/\u521b\u5efaThread\u5bf9\u8c61,\u7ebf\u7a0b\u51fd\u6570\u4e3aEventLoopThread::threadFunc,\u5e76\u4f20\u5165this\u6307\u9488\u4ee5\u4fbf\u5728\u7ebf\u7a0b\u51fd\u6570\u4e2d\u8bbf\u95ee\u5f53\u524d
\n \/\/\u5bf9\u8c61,name\u662f\u7ebf\u7a0b\u540d\u79f0
\n \/\/\u6ce8\u610f:\u6b64\u65f6\u7ebf\u7a0b\u8fd8\u6ca1\u6709\u542f\u52a8,thread_\u5bf9\u8c61\u53ea\u662f\u6784\u9020\u5b8c\u6574,thread_.start()\u5e76\u6ca1\u6709\u8fdb\u884c\u8c03\u7528
\nEventLoopThread::~EventLoopThread() {
\n exiting_ = true;
\n if (loop_) {
\n loop_->quit();
\n thread_.join();
\n }
\n}<\/p>\n

EventLoop* EventLoopThread::startLoop() {
\n thread_.start();\/\/\u542f\u52a8\u5e95\u5c42\u7ebf\u7a0b,\u7ebf\u7a0b\u5165\u53e3\u51fd\u662fthreadFunc
\n std::unique_lock<std::mutex> lock(mutex_);
\n cond_.wait(lock, [this]() { return loop_ != nullptr; });\/\/\u5e26\u8c13\u8bcd\u7684\u5b89\u5168\u7248\u672c,\u7b2c\u4e8c\u4e2a\u53c2\u6570\u8fd4\u56de\u503c\u4e3abool\u7c7b\u578b,\u662f\u4e00\u4e2alambda\u8868\u8fbe\u5f0f
\n return loop_;\/\/\u4e00\u65e6\u5b50\u7ebf\u7a0b\u5b8c\u6210\u521d\u59cb\u5316\u5e76\u901a\u77e5\u6761\u4ef6\u53d8\u91cf,startLoop()\u8fd4\u56de\u6307\u5411\u8be5EventLoop\u7684\u6307\u9488
\n \/\/\u6b64\u540e\u5916\u90e8\u5c31\u53ef\u4ee5\u901a\u8fc7\u8fd9\u4e2a\u6307\u9488\u8fdb\u884c\u8de8\u7ebf\u7a0b\u8c03\u7528(\u5982runInLoop)
\n}<\/p>\n

void EventLoopThread::threadFunc() {
\n EventLoop loop;\/\/\u6ce8\u610f\u8fd9\u91cc\u5e76\u4e0d\u662fnew\u800c\u662f\u5728\u6808\u4e0a\u521b\u5efa\u5bf9\u8c61
\n static int idx = 1;
\n loop.setIndex(idx++);\/\/\u8bbe\u7f6e\u7d22\u5f15<\/p>\n

{
\n std::lock_guard<std::mutex> lock(mutex_);
\n loop_ = &loop;\/\/\u628a\u6808\u5bf9\u8c61\u7684\u5730\u5740\u8d4b\u503c\u7ed9\u6210\u5458\u53d8\u91cf
\n cond_.notify_one();\/\/\u901a\u77e5startLoop\u5df2\u7ecf\u5c31\u7eea
\n }
\n LOG_INFO("[SUCCESS] Sub Reactor \\\\"" + thread_.name() + "\\\\" (\u7ebf\u7a0bID: " +
\n std::to_string(std::hash<std::thread::id>{}(std::this_thread::get_id())) + ") \u5df2\u542f\u52a8");
\n loop.loop();\/\/\u8fdb\u5165\u4e8b\u4ef6\u5faa\u73af
\n \/\/\u8c03\u7528 EventLoop::loop(),\u8be5\u51fd\u6570\u5185\u90e8\u662f\u4e00\u4e2a\u65e0\u9650\u5faa\u73af(\u77e5\u9053quit()\u88ab\u8c03\u7528),\u5904\u7406 I\/O \u4e8b\u4ef6\u548c\u8de8\u7ebf\u7a0b\u56de\u8c03\u3002
\n std::lock_guard<std::mutex> lock(mutex_);
\n loop_ = nullptr;\/\/\u5faa\u73af\u7ed3\u675f,\u8fdb\u884c\u6e05\u7406
\n} <\/p>\n

threadFunc()\u5728\u6808\u4e0a\u521b\u5efaEventLoop\u5bf9\u8c61，\u8fd9\u6837\u5c31\u6709\u4e00\u4e2a\u597d\u5904，\u751f\u547d\u5468\u671f\u4e0e\u7ebf\u7a0b\u7ed1\u5b9a，\u7ebf\u7a0b\u9000\u51fa\u65f6\u81ea\u52a8\u9500\u6bc1，\u65e0\u9700\u624b\u52a8\u8fdb\u884cdelete\u3002<\/p>\n

\u6bcf\u4e2aEventLoopThread\u5b9e\u4f8b\u552f\u4e00\u5bf9\u5e94\u4e00\u4e2a\u5b50\u7ebf\u7a0b，\u4e14\u8be5\u7ebf\u7a0b\u53ea\u8fd0\u884c\u8fd9\u4e2aEventLoop，\u5b9e\u73b0\u4e86One Loop Per Thread\u3002<\/p>\n

7\u3001EventLoopThreadPool:<\/h3>\n

EventLoopThreadPool\u00a0\u521b\u5efa\u5e76\u6301\u6709\u591a\u4e2a\u00a0EventLoopThread，\u6bcf\u4e2a\u00a0EventLoopThread\u00a0\u542f\u52a8\u540e\u4ea7\u751f\u4e00\u4e2a\u5b50\u7ebf\u7a0b\u53ca\u5176\u00a0EventLoop\u3002<\/p>\n

\/*
\nEventLoopThreadPool\u662fAeroChat\u4e2d\u7ba1\u7406\u591a\u4e2a\u5b50Reactor\u7ebf\u7a0b\u7684\u6838\u5fc3\u7c7b,\u5b83\u5c01\u88c5\u4e86\u591a\u4e2aEventLoopThead,\u5bf9\u5916\u63d0\u4f9b
\n\u7edf\u4e00\u7684\u63a5\u53e3\u6765\u83b7\u53d6\u5b50Reactor\u7684EventLoop,\u8d1f\u8d23\u65b0\u8fde\u63a5\u7684\u8d1f\u8f7d\u5747\u8861
\n*\/
\n#ifndef EVENTLOOPTHREADPOOL_HPP
\n#define EVENTLOOPTHREADPOOL_HPP<\/p>\n

#include <vector>
\n#include <memory>
\n#include <string>
\n#include "EventLoop.hpp"
\n#include "EventLoopThread.hpp"
\n#include<atomic><\/p>\n

class EventLoopThreadPool {
\npublic:
\n EventLoopThreadPool(EventLoop* baseLoop, int numThreads);
\n ~EventLoopThreadPool() = default;<\/p>\n

void start();\/\/\u5f00\u542f\u6240\u4ee5\u7ebf\u7a0b,\u8fdb\u884cloop
\n EventLoop* getNextLoop(); \/\/ \u65e0\u53c2\u83b7\u53d6\u4e0b\u4e00\u4e2aloop
\n EventLoop* getLoop(int idx); \/\/ \u6839\u636e\u7d22\u5f15\u83b7\u53d6\u6307\u5b9aloop
\n int getThreadNum() const; \/\/ \u83b7\u53d6\u7ebf\u7a0b\u6570（\u4ec5\u58f0\u660e）
\n std::vector<EventLoop*> getAllLoops() const; \/\/ \u83b7\u53d6\u6240\u6709loop（\u4ec5\u58f0\u660e）<\/p>\n

private:
\n EventLoop* baseLoop_; \/\/ \u4e3bReactor\u7684loop
\n int numThreads_; \/\/ \u5b50Reactor\u6570\u91cf
\n std::atomic<int>next_{0}; \/\/ \u8f6e\u8be2\u7d22\u5f15
\n bool started_; \/\/ \u662f\u5426\u542f\u52a8
\n std::vector<std::unique_ptr<EventLoopThread>> threads_; \/\/ \u5b50\u7ebf\u7a0b\u5217\u8868
\n std::vector<EventLoop*> loops_; \/\/ \u5b50loop\u5217\u8868 \u5b58\u50a8\u6240\u4ee5EventLoop\u5bf9\u5e94\u7684\u6307\u9488
\n};<\/p>\n

#endif \/\/ EVENTLOOPTHREADPOOL_HPP <\/p>\n

\u4e09\u3001\u670d\u52a1\u5668\u8fd0\u884c\u6d41\u7a0b:<\/h2>\n

\u770b\u4e86\u4e0a\u9762\u7684\u5404\u4e2a\u7ec4\u4ef6\u53ef\u80fd\u5e76\u4e0d\u80fd\u6574\u4e2a\u670d\u52a1\u5668\u7684\u6d41\u7a0b，\u4e0b\u9762\u6211\u5c06\u4ecemain\u51fd\u6570\u5165\u624b，\u8be6\u7ec6\u8bb2\u89e3\u4e00\u4e0b\u8fd9\u4e2a\u670d\u52a1\u5668\u7684\u8fd0\u884c\u6d41\u7a0b，\u4ee5\u4fbf\u4e8e\u5927\u5bb6\u7406\u89e3\u3002<\/p>\n

int main(int argc, char* argv[]) {
\n signal(SIGPIPE, SIG_IGN);<\/p>\n

if (argc < 2) {
\n printf("Usage: %s port\\\\n", argv[0]);
\n return 1;
\n }<\/p>\n

uint16_t port = static_cast<uint16_t>(atoi(argv[1]));
\n EventLoop loop; \/\/\u521b\u5efa\u4e00\u4e2aEventLoop\u5bf9\u8c61loop
\n int subReactorNum = std::thread::hardware_concurrency();\/\/\u7531\u4e8e\u6211\u7684\u670d\u52a1\u5668\u662f8\u68388GB,\u6240\u4ee5\u8fd9\u91cc\u7684
\n \/\/subReactorNum=\u6211\u7684cpu\u6838\u5fc3\u6570\u4e5f\u5c31\u662f\u7b49\u4e8e8
\n ChatServer server(&loop, port, subReactorNum);<\/p>\n

server.start();\/\/\u542f\u52a8\u670d\u52a1\u5668
\n loop.loop();\/\/\u5f00\u59cbloop
\nprintf("\u670d\u52a1\u5668\u542f\u52a8\u6210\u529f！\\\\n");<\/p>\n

return 0;
\n}<\/p>\n

\u9996\u5148\u770b\u670d\u52a1\u5668\u4e3b\u51fd\u6570，\u9996\u5148\u521b\u5efa\u4e00\u4e2aEventLoop\u4e5f\u5c31\u662f\u4e3bEventLoop,\u7136\u540e\u521b\u5efa\u4e00\u4e2aserver\u5bf9\u8c61，\u6267\u884cChatServer::start()\u3002<\/p>\n

void ChatServer::start() {
\n threadPool_->start();<\/p>\n

listenFd_ = sock_.Socket();
\n int reuse = 1;
\n setsockopt(listenFd_, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
\n setsockopt(listenFd_, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse));
\n fcntl(listenFd_, F_SETFL, O_NONBLOCK | FD_CLOEXEC);
\n sock_.Bind(listenFd_, port_);
\n sock_.Listen(listenFd_, 8192);<\/p>\n

acceptChannel_ = std::make_unique<Channel>(loop_, listenFd_);
\n acceptChannel_->setReadCallback([this] { handleAccept(); });
\n acceptChannel_->enableReading();
\n acceptChannel_->enableET();
\n loop_->updateChannel(acceptChannel_.get());<\/p>\n

LOG_INFO("[EchoServer] Started on port " + std::to_string(port_));
\n}<\/p>\n

\u7136\u540e\u6267\u884cthreadPool_.start()\u3002<\/p>\n

void EventLoopThreadPool::start() {
\n \/\/\u542f\u52a8\u6240\u6709Reactor\u5bf9\u5e94\u7684\u7ebf\u7a0b,\u5f00\u542f\u4e8b\u4ef6\u5faa\u73af(loop)
\n if (started_) return;
\n started_ = true;
\n for (int i = 0; i < numThreads_; ++i) {
\n auto t = std::make_unique<EventLoopThread>("SubReactor-" + std::to_string(i));
\n EventLoop* subLoop = t->startLoop();
\n loops_.push_back(subLoop);
\n threads_.push_back(std::move(t));
\n }
\n}<\/p>\n

\u8fd9\u4e2a\u51fd\u6570\u4f1a\u5f00\u542f\u6240\u6709\u7684EventLoop,\u4e00\u4e2aSubReactor\/SubLoop\u5bf9\u5e94\u4e00\u4e2a\u7ebf\u7a0b\u3002t\u662f\u4e00\u4e2astd::unique_ptr<EventLoopThread>\u00a0\u5bf9\u8c61，\u7136\u540e\u901a\u8fc7\u8fd9\u4e2a\u667a\u80fd\u6307\u9488\u53bb\u8c03\u7528EventLoopThread::startLoop()，\u90a3\u4e48startLoop()\u00a0\u5185\u90e8\u5177\u4f53\u662f\u5982\u4f55\u5f00\u542f\u4e00\u4e2a\u7ebf\u7a0b\u5e76\u8fd0\u884c\u4e8b\u4ef6\u5faa\u73af\u7684\u5462？<\/p>\n

\"\"<\/p>\n

thread_\u662f\u4e00\u4e2aThread\u7c7b\u7684\u5bf9\u8c61，\u6240\u4ee5\u6211\u4eec\u770b\u4e00\u4e0bThread::start()\u3002<\/p>\n

\"\"<\/p>\n

\u8fd9\u4e2aThread\u7c7b\u7684\u6784\u9020\u51fd\u6570\u7684\u7b2c\u4e00\u4e2a\u53c2\u6570\u662f\u4e00\u4e2a\u56de\u8c03\u51fd\u6570\u3002\u88ab\u7ed1\u5b9a\u5230\u4e86threadFunc，\u4e5f\u5c31\u662f\u8bf4Thread\u6784\u9020\u65f6\u5c31\u4f1a\u56de\u8c03threadFunc\u8fd9\u4e2a\u56de\u8c03\u51fd\u6570\u3002<\/p>\n

\"\"<\/p>\n

\u5982\u4e0a\u5c31\u5b9e\u73b0\u4e86One Loop Per Thread，\u7136\u540e\u4e3b\u7ebf\u7a0b\u518d\u6267\u884cloop()\u3002\u5f53\u6709\u65b0\u8fde\u63a5\u5230\u6765\u7684\u65f6\u5019\u5c31\u56de\u8c03handleAcceptor，\u4e3b\u7ebf\u7a0b\u53ea\u8d1f\u8d23\u63a5\u6536\u65b0\u8fde\u63a5\u7136\u540e\u901a\u8fc7\u8f6e\u8be2\u7684\u65b9\u5f0f\u5c06\u8fd9\u4e9b\u65b0\u8fde\u63a5\u5206\u53d1\u7ed9\u4e0d\u540c\u7684\u5b50Reactor\/\u5b50Loop,\u5b50Reactor\u53bb\u6267\u884chandleNewConnection()\u3002\u8fd9\u5c31\u662f\u4e3b\u4eceReactor！\u4e5f\u662f\u8be5\u670d\u52a1\u5668\u9ad8\u6027\u80fd\u7684\u5173\u952e\u6240\u5728\u3002<\/p>\n

\u66f4\u591a\u7ec6\u8282\u53ef\u67e5\u770b\u6e90\u7801:<\/p>\n

AeroChat\/benchmark at master \u00b7 ywx914705\/AeroChat<\/p>\n

\u5b8c\u6574\u9879\u76ee(\u9ad8\u6027\u80fd\u804a\u5929\u5ba4\u670d\u52a1\u5668）\u6e90\u7801：<\/p>\n

ywx914705\/AeroChat: AeroChat \u662f\u4e00\u4e2a\u4f7f\u7528 C++11 \u5f00\u53d1\u7684\u9ad8\u5e76\u53d1\u804a\u5929\u670d\u52a1\u5668，\u91c7\u7528 **\u4e3b\u4ece Reactor + \u5f02\u6b65\u4efb\u52a1\u961f\u5217** \u67b6\u6784，\u652f\u6301\u5355\u673a\u6570\u4e07\u5e76\u53d1\u8fde\u63a5\u3002\u9879\u76ee\u5b9e\u73b0\u4e86\u5b8c\u6574\u7684\u7528\u6237\u8ba4\u8bc1\u3001\u79c1\u804a\u3001\u7fa4\u804a\u3001\u79bb\u7ebf\u6d88\u606f\u3001\u4f1a\u8bdd\u7ba1\u7406\u7b49\u529f\u80fd，\u5e76\u96c6\u6210\u4e86 MySQL \u4e0e Redis \u4f5c\u4e3a\u5b58\u50a8\u5c42\u3002<\/p>\n

\u9879\u76ee\u5df2\u5f00\u6e90,\u914d\u5957\u5b8c\u6574\u7684README，\u89c9\u5f97\u5199\u7684\u4e0d\u9519\u7684\u670b\u53cb\u53ef\u4ee5\u5e2e\u5fd9star\u4e00\u4e0b，\u8c22\u8c22！！！<\/span><\/p>\n

\u56db\u3001\u53c2\u8003\u8d44\u6599：<\/h2>\n