muduo net库学习笔记8——件驱动循环线程池EventLoopThreadPool

最新推荐文章于 2022-09-23 14:43:17 发布
最新推荐文章于 2022-09-23 14:43:17 发布
阅读量286 收藏 1
点赞数
分类专栏： muduo源码 文章标签： muduo网络库
原文链接：https://blog.csdn.net/sinat_35261315/article/details/78376821
版权

感谢并转载自https://blog.csdn.net/sinat_35261315/article/details/78376821

线程池的作用体现在

  • 用户启动TcpServer服务器时创建大量子线程，每个子线程创建一个EventLoop并开始执行EventLoop::loop
  • 主线程的线程池保存着创建的这些线程和EventLoop
  • 当Acceptor接收到客户端的连接请求后返回TcpServer，TcpServer创建TcpConnection用于管理tcp连接
  • TcpServer从事件驱动线程池中取出一个EventLoop，并将这个EventLoop传给TcpConnection的构造函数
  • TcpConnection创建用于管理套接字的Channel并注册到从线程池中取出的EventLoop的Poller中
  • 服务器继续监听

这个池子既是一个线程池，又是一个EventLoop池，二者是等价的，一个EventLoop对应一个线程

线程池中比较复杂的地方是由主线程创建子线程，子线程创建EventLoop并执行EventLoop::loop，主线程返回创建的EventLoop给线程池并保存起来，比较绕
（主线程创子线程， 子线程创建EventLoop，主线程返回创建的EventLoop给线程池并保存起来）

EventLoopThreadPool定义

class EventLoopThreadPool : noncopyable
{
 public:
  typedef std::function<void(EventLoop*)> ThreadInitCallback;

  EventLoopThreadPool(EventLoop* baseLoop, const string& nameArg);
  ~EventLoopThreadPool();
  void setThreadNum(int numThreads) { numThreads_ = numThreads; }
  void start(const ThreadInitCallback& cb = ThreadInitCallback());//开启线程池，创建线程

  // valid after calling start()
  /// round-robin
  EventLoop* getNextLoop();//获取一个线程（事件驱动循环），通常在创建TcpConnection时调用 

  /// with the same hash code, it will always return the same EventLoop
  EventLoop* getLoopForHash(size_t hashCode);

  std::vector<EventLoop*> getAllLoops();

  bool started() const
  { return started_; }

  const string& name() const
  { return name_; }

 private:

  EventLoop* baseLoop_;//主线程的事件驱动循环，TcpServer所在的事件驱动循环，创建TcpServer传入的EventLoop
  string name_;
  bool started_;
  int numThreads_;//线程数
  int next_;//标记下次应该取出哪个线程，采用round_robin
  
  std::vector<std::unique_ptr<EventLoopThread>> threads_;//线程池中的所有线程
  std::vector<EventLoop*> loops_;
   /* 
   * 线程池中每个线程对应的事件驱动循环，从线程池取出线程实际上返回的是事件驱动循环
   * 每个事件驱动循环运行在一个线程中
   */
};
  • baseLoop_是主线程所在的事件驱动循环，即TcpServer所在的那个主线程，这个事件驱动循环通常只负责监听客户端连接请求，即Acceptor的Channel。
  • 两个vector保存着所有子线程即每个子线程对应的EventLoop。事件驱动循环线程被封装在EventLoopThread中，EventLoopThread中使用的Thread才是真正的线程封装

线程池是由TcpServer启动的，在TcpServer::start函数中（由用户调用）

/* 
 * 开启事件驱动循环线程池，将Acceptor的Channel添加到EventLoop中，注册到Poller上
 * 此时还没有调用EventLoop::loop()，所以还没有开启监听
 */
void TcpServer::start()
{
  if (started_.getAndSet(1) == 0)
  {
    /* 启动线程池 */
    threadPool_->start(threadInitCallback_);

    assert(!acceptor_->listenning());
    /* 
     * Acceptor和TcpServer在同一个线程，通常会直接调用 
     * std::bind只能值绑定，如果传入智能指针会增加引用计数，这里传递普通指针
     * 因为TcpServer没有销毁，所以不用担心Accepor会销毁
     */
    loop_->runInLoop(
        std::bind(&Acceptor::listen, get_pointer(acceptor_)));
  }
}

TcpServer::start中调用threadPool_->start()用于启动线程池，传入的参数是创建好所有线程后调用的回调函数，也是由用户提供

void EventLoopThreadPool::start(const ThreadInitCallback& cb)
{
  assert(!started_);
  baseLoop_->assertInLoopThread();

  started_ = true;

  /* 创建一定数量的线程（事件驱动循环） */
  for (int i = 0; i < numThreads_; ++i)
  {
    char buf[name_.size() + 32];
    snprintf(buf, sizeof buf, "%s%d", name_.c_str(), i);
    /* EventLoopThread，事件驱动循环线程*/
    EventLoopThread* t = new EventLoopThread(cb, buf);
    threads_.push_back(std::unique_ptr<EventLoopThread>(t));
    /* 创建新线程，返回新线程的事件驱动循环EventLoop */
    loops_.push_back(t->startLoop());
  }
  if (numThreads_ == 0 && cb)
  {
    cb(baseLoop_);
  }
}
  1. 线程池所在线程是主线程，所有通过pthread_create创建的线程为子线程
  2. 创建线程首先构造EventLoopThread对象，这里保存着一个事件驱动循环loop_和线程Thread，但是事件驱动循环初始为null，Thread初始时设置了回调函数，在创建完线程后执行
  3. 执行EventLoopThread::startLoop函数启动Thread创建子线程，主线程返回阻塞在loop_上因为它为null，子线程执行回调函数创建EventLoop并赋值给loops_，同时唤醒主线程
  4. 主线程返回loops_，子线程执行EventLoop::loop开始监听事件
/* 
 * 线程池所在线程在每创建一个EventLoopThread后会调用相应对象的startLoop函数，注意主线程和子线程之分
 * 主线程是TcpServer所在线程，也是线程池所在线程
 * 子线程是由线程池通过pthread_create创建的线程，每一个子线程运行一个EventLoop::loop 
 * 
 * 1.主线程EventLoopThreadPool创建EventLoopThread对象
 * 2.主线程EventLoopThread构造函数中初始化线程类Thread并传递回调函数EventLoopThread::threadFunc
 * 3.主线程EventLoopThreadPool创建完EventLoopThread后，调用EventLoopThread::startLoop函数
 * 4.主线程EventLoopThread::startLoop函数开启线程类Thread，即调用Thread::start
 * 5.主线程Thread::start函数中使用pthread_create创建线程后
 *   子线程调用回调函数EventLoopThread::threadFunc，主线程返回到EventLoopThread::startLoop
 * 6.主线程EventLoopThread::startLoop由于当前事件驱动循环loop_为null（构造时初始化为null）导致wait
 * 7.子线程EventLoopThread::threadFunc创建EventLoop并赋值给loop_，然后唤醒阻塞在cond上的主线程
 * 8.主线程EventLoopThread::startLoop被唤醒后，返回loop_给EventLoopThreadPool
 * 9.主线程EventLoopThreadPool保存返回的loop_，存放在成员变量std::vector<EventLoop*> loops_中
 * 10.子线程仍然在threadFunc中，调用EventLoop::loop函数，无限循环监听
 */

EventLoop* EventLoopThread::startLoop()
{
  assert(!thread_.started());
  /* 主线程调用线程类的start函数，创建线程 */
  thread_.start();

  {
    /* 加锁，原因是loop_可能会被子线程更改 */
    MutexLockGuard lock(mutex_);
    /*
     * 如果loop_仍然为null，说明子线程那边还没有进入threadFunc创建EventLoop，wait等待
     * pthread_cond_wait(pthread_cond_t&, pthread_mutex_t&);会自动解锁，然后睡眠
     * 等待某个线程使用pthread_cond_signal(&pthread_cond_t&);或pthread_cond_boardcast(pthread_cond_t&)
     * 唤醒wait的一个/全部线程
     * 当主线程从wait中返回后，子线程已经创建了EventLoop，主线程返回到EventLoopThreadPool中
     * 子线程执行EventLoop::loop函数监听事件
     */
    while (loop_ == NULL)
    {
      cond_.wait();
    }
  }

  return loop_;
}

Thread类通过调用pthread_create创建子线程

/* EventLoopThread::startLoop函数中调用，用于创建子线程 */
void Thread::start()
{
  assert(!started_);
  started_ = true;
  // FIXME: move(func_)
  /* 创建子线程为线程函数提供的参数，封装起来就可以实现传递多个参数 */
  detail::ThreadData* data = new detail::ThreadData(func_, name_, &tid_, &latch_);
  /* 创建线程，子线程调用detail::startThread，主线程继续向下执行 */
  if (pthread_create(&pthreadId_, NULL, &detail::startThread, data))
  {
    started_ = false;
    delete data; // or no delete?
    LOG_SYSFATAL << "Failed in pthread_create";
  }
  else
  {
    /* 如果线程创建成功，主线程阻塞在这里 */
    latch_.wait();
    assert(tid_ > 0);
  }
}

创建成功后，主线程阻塞在latch_.wait()上（条件变量），等待子线程执行threadFunc之前被唤醒
ThreadData是线程数据类，将线程函数用到的所有参数都存在这里面即可，线程函数为detail::startThread，进而调用runInThread

/* 创建线程后调用的函数，data是参数 */
void* startThread(void* obj)
{
  ThreadData* data = static_cast<ThreadData*>(obj);
  data->runInThread();
  delete data;
  return NULL;
}

runInLoop调用latch_->countDown，此时会唤醒主线程，主线程回到startLoop中由于loop_为null阻塞在wait上。而此时子线程正在准备调用threadFunc（在EventLoopThread创建之初将EventLoopThread::threadFunc传递给Thread，用于在创建完线程后调用）

  /* 
   * 创建线程后间接调用的函数，用于执行EventLoopThread::threadFunc
   * 这个函数在EventLoopThread构造时传给Thread对象的
   * EventLoopThread::startLoop函数中调用Thread对象的Thread::start函数
   * Thread::start中创建子线程，子线程调用detail::startThread，进而调用detail::runInThread
   * detail::runInLoop调用EventLoopThread::threadFunc，创建EventLoop，唤醒主线程，子线程执行loop循环
   * 转了一大圈又回到EventLoopThread中
   */
  void runInThread()
  {
    *tid_ = muduo::CurrentThread::tid();
    tid_ = NULL;
    latch_->countDown();
    latch_ = NULL;

    muduo::CurrentThread::t_threadName = name_.empty() ? "muduoThread" : name_.c_str();
    /* 给当前线程命名 */
    ::prctl(PR_SET_NAME, muduo::CurrentThread::t_threadName);
    try
    {
      /* EventLoopThread::threadFunc() */
      func_();
      muduo::CurrentThread::t_threadName = "finished";
    }
    catch (const Exception& ex)
    {
      muduo::CurrentThread::t_threadName = "crashed";
      fprintf(stderr, "exception caught in Thread %s\n", name_.c_str());
      fprintf(stderr, "reason: %s\n", ex.what());
      fprintf(stderr, "stack trace: %s\n", ex.stackTrace());
      abort();
    }
    catch (const std::exception& ex)
    {
      muduo::CurrentThread::t_threadName = "crashed";
      fprintf(stderr, "exception caught in Thread %s\n", name_.c_str());
      fprintf(stderr, "reason: %s\n", ex.what());
      abort();
    }
    catch (...)
    {
      muduo::CurrentThread::t_threadName = "crashed";
      fprintf(stderr, "unknown exception caught in Thread %s\n", name_.c_str());
      throw; // rethrow
    }
  }

兜兜转转又回到了EventLoopThread，此时主线程阻塞在EventLoopThread::startInLoop的wait上，子线程在EventLoopThread::threadFunc中，准备创建一个EventLoop然后唤醒主线程，并开启事件循环

/* 
 * 传递给线程的回调函数，当创建线程后，在detail::runInLoop会回调这个函数
 * 此函数创建一个事件驱动循环，并开启事件监听(loop)
 */
void EventLoopThread::threadFunc()
{
  /* 子线程创建事件驱动循环 */
  EventLoop loop;

  if (callback_)
  {
    callback_(&loop);
  }

  {
    /* 上锁后赋值给loop_ */
    MutexLockGuard lock(mutex_);
    loop_ = &loop;
    /* 
     * pthread_cond_signal(pthread_cond_t&)唤醒一个wait的线程
     * 此时主线程发现loop_已经不为null，随后返回到EventLoopThreadPool中
     */
    cond_.notify();
  }

  /* 子线程开启事件监听，进入无限循环，不返回 */
  loop.loop();
  //assert(exiting_);
  loop_ = NULL;
}

子线程将一直停留在loop.loop()上，主线程由于被子线程唤醒，发现loop_已经不为null，说明已经创建了一个线程，同时也在那个线程中创建了一个事件驱动循环，所以主线程返回，将创建好的事件驱动循环返回给线程池保存起来，当有新的TcpConnection被创建后取出一个用来监听tcp连接

void EventLoopThreadPool::start(const ThreadInitCallback& cb)
{
  assert(!started_);
  baseLoop_->assertInLoopThread();

  started_ = true;

  /* 创建一定数量的线程（事件驱动循环） */
  for (int i = 0; i < numThreads_; ++i)
  {
    char buf[name_.size() + 32];
    snprintf(buf, sizeof buf, "%s%d", name_.c_str(), i);
    /* EventLoopThread，事件驱动循环线程*/
    EventLoopThread* t = new EventLoopThread(cb, buf);
    threads_.push_back(std::unique_ptr<EventLoopThread>(t));
    /* 创建新线程，返回新线程的事件驱动循环EventLoop */
    /* EventLoopThread主线程返回后，将事件驱动循环保存下来，然后继续创建线程 */
    loops_.push_back(t->startLoop());
  }
  if (numThreads_ == 0 && cb)
  {
    cb(baseLoop_);
  }
}

至此线程池的创建工作完成，每一个线程都运行着EventLoop::loop，进行EventLoop::loop -> Poller::poll -> Channel::handleEvent -> TcpConnection::handle* -> EventLoop::doPendingFunctors -> EventLoop::loop的工作。
如果提供了回调函数，在创建完成后也会执行，但通常用户不会在意线程池的创建工作，所以一般都不提供

创建完成后，线程池唯一的工作就是在新建TcpConnection时从池子中取出一个EventLoop传给TcpConnection

void TcpServer::newConnection(int sockfd, const InetAddress& peerAddr)
{
  loop_->assertInLoopThread();
  /* 从事件驱动线程池中取出一个线程给TcpConnection */
  EventLoop* ioLoop = threadPool_->getNextLoop();
  /* 为TcpConnection生成独一无二的名字 */
  char buf[64];
  snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
  ++nextConnId_;
  string connName = name_ + buf;

  LOG_INFO << "TcpServer::newConnection [" << name_
           << "] - new connection [" << connName
           << "] from " << peerAddr.toIpPort();
  /* 
   * 根据sockfd获取tcp连接在本地的<地址，端口>
   * getsockname(int fd, struct sockaddr*, int *size);
   */
  InetAddress localAddr(sockets::getLocalAddr(sockfd));
  // FIXME poll with zero timeout to double confirm the new connection
  // FIXME use make_shared if necessary
  /* 创建一个新的TcpConnection代表一个Tcp连接 */
  TcpConnectionPtr conn(new TcpConnection(ioLoop,
                                          connName,
                                          sockfd,
                                          localAddr,
                                          peerAddr));
    ...
}

EventLoopThreadPool::getNextLoop函数如下，用于取出一个EventLoop。
如果线程池中没有线程，就返回主线程的EventLoop，此时只有一个EventLoop在运行，即TcpServer的那个

/* 从线程池中取出一个线程，挨着取 */
EventLoop* EventLoopThreadPool::getNextLoop()
{
  baseLoop_->assertInLoopThread();
  assert(started_);
  /* 线程池所在线程，TcpServer的主线程 */
  EventLoop* loop = baseLoop_;

  /* 
   * 如果不为空，取出一个
   * 如果为空，说明线程池中没有创建线程，是单线程程序，返回主线程
   */
  if (!loops_.empty())
  {
    // round-robin
    /* loops_保存所有的线程 */
    loop = loops_[next_];
    ++next_;
    if (implicit_cast<size_t>(next_) >= loops_.size())
    {
      next_ = 0;
    }
  }
  return loop;
}
听说西佳佳难得很
关注
专栏目录
深入理解 Event Loop事件循环机制
01-08
Event Loop事件循环机制 事件循环机制（Event Loop）是全面了解javascript代码执行顺序绕不开的一个重要知识点。 为什么会有事件循环机制？ javascript从诞生之日起就是一门单线程的非阻塞的脚本语言。这是由其最初的用途来决定的：与浏览器交互。 首先等来了解js为什么是单线程的吧！ 首先要明白线程的概念？ 进程是资源分配的最小单位，线程是进程的一部分，是cpu调度的基本单位； 了解浏览器 浏览器中，每次打开一个tab页面，其实就是新开了一个进程，在这个进程中，还有js引擎线程、ui渲染线程、http请求线程。 这里面还可深入了解js引擎线程、ui渲染线程、http请
muduo网络库学习（四）事件驱动循环EventLoop
一个程序渣渣的小后院
10-24 3378
muduo的设计采用高并发服务器框架中的one loop per thread模式，即一个线程一个事件循环。 这里的loop，其实就是muduo中的EventLoop，所以到目前为止，不管是Poller，Channel还是TimerQueue都仅仅是单线程下的任务，因为这些都依赖于EventLoop。这每一个EventLoop，其实也就是一个Reactor模型。 而多线程体现在EventLoop
muduo源码分析之EventLoop、Channel、Poller的实现
上善若水
11-25 1198
muduo源码分析之 简单的EventLoop、Channel Poller实现
muduo网络库学习之EventLoop（一）：事件循环类图简介和muduo 定时器TimeQueue
热门推荐
Meditation
11-07 1万+
1、EventLoop、Channel、Poller 等类图如下： 黑色菱形：组合；白色菱形：聚合；白色三角形：继承；实线：关联； Channel是selectable IO channel，负责注册与响应IO 事件，它不拥有file descriptor。 Channel是Acceptor、Connector、EventLoop、TimerQueue、TcpConn
C++11重写muduo网络库4——EventLoop(封装Channel和Epoller)
baidu_41553551的博客
09-23 904
持续循环监听，EventLoop整合封装了Channel和Poller并向上提供了更方便的接口来使用，也就是持续循环的获取监听结果并且根据结果调用处理函数。Channel类起到了将fd及其相关属性封装的作用，将fd及其感兴趣事件和发生的事件以及不同事件对应的回调函数封装在一起Poller包含了Channel对象负责从事件监听器上获取监听信息，并有接口让Channel做出反应。EventLoop包含了Poller类，起到一个驱动循环。
Muduo_网络库使用手册
09-12
Muduo网络库是一款高效、稳定且易于使用的开源库，专为C++11设计，它提供了异步事件驱动的网络应用框架，适用于服务器端的开发。 Muduo网络库的核心特性包括： 1. **非阻塞I/O**：Muduo使用了Linux的epoll系统调用...
muduo网络库/网络库/网络库.rar
08-18
muduo网络库遵循了“反应器”模式的设计，这种模式的核心在于通过事件驱动来处理网络I/O操作，使得程序能够以非阻塞的方式处理大量并发连接。此外，muduo采用了面向对象的设计，通过类的封装和继承，实现了代码的...
完整muduo网络库
04-01
**muduo网络库详解** muduo是一个开源的C++网络库，专为高性能、高并发的服务器设计。这个库由陈硕在2010年开发，它基于事件驱动模型，支持非阻塞I/O，使得在处理大量并发连接时能够保持高效的性能。在本文中，我们...
基于C++11的muduo网络库.zip
最新发布
03-06
适合学习/练手、毕业设计、课程设计、期末/期中/大作业、工程实训、相关项目/竞赛学习等。 项目具有较高的学习借鉴价值，也可直接拿来修改复现。可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。 可放心...
muduo C++网络库 源码（linux）
05-12
总的来说，muduo C++网络库是一个极好的学习资源，对于想要掌握现代C++和网络编程的开发者来说，阅读和理解其源码无疑是一次宝贵的学习经历。通过探索muduo，你可以更好地理解如何构建高效的并发服务器，以及如何...
muduo网络库学习之EventLoop（一）：事件循环类图简介
wk_bjut_edu_cn的博客
06-29 2776
番外 TCP网络编程本质    TCP网络编程最本质是的处理三个半事件 连接建立：服务器accept（被动）接受连接，客户端connect（主动）发起连接 连接断开：主动断开（close、shutdown），被动断开（read返回0） 消息到达：文件描述符可读   消息发送完毕：这算半个。对于低流量的服务，可不必关心这个事件;这里的发送完毕是指数据写入操作系统缓冲区，将由TCP协议栈负责...
【Muduo源码分析】muduo的EventLoop 解读
08-13 539
Muduo奉行的是每个one loop per thread，意思是每个线程只有一个EventLoop对象。在Muduo中，称创建了EventLoop对象的线程是IO线程。 我主要关注大体框架，有些细节暂时不关注。首先看看构造函数（下列源码源自Muduo的教程示例） EventLoop::EventLoop() : looping_(false), quit_(false), ...
muduo源码解析之EventLoopThread
Swartz2015的专栏
02-24 1027
回到TcpServer，我们记得里面有一个Eventloopthreadpool，根据名字，这是一个线程池，它主要用于管理所有的eventloop，每个eventloop对应一个线程。当新连接到来时，Acceptor事件分发器将连接分发到合适的线程中。线程里面核心是执行Eventloop类里面的loop函数，这个函数主要是执行epoll_wait和一些其他的处理函数。loop是一个while循环。m
muduo -- eventloop分析1
andylau00j的专栏
12-27 546
几个问题： currentActiveChannel_-&amp;amp;amp;gt;handleEvent(pollReturnTime_); 如果handleEvent内某个事件响应函数很慢或者卡住，岂不是会影响后续事件处理延迟，且影响该eventloop thread的poll执行。 muduo 对虚基类接口，类似如下定义 class ICallBcak { public: virtual ...
muduo学习笔记：net部分之EventLoop
热爱生活，忠于自己
08-19 541
EventLoop的事件循环主要两个大部分：第一个部分，`Poller`监听`socketfd`、`timerfd`封装的`Channel`事件（网络事件、定时器事件），并执行对应IO事件的回调函数；第二个部分，在IO线程空闲时执行一些计算任务，充分利用线程资源。由于`Poller`是阻塞等待IO事件的，当有计算任务时需要被唤醒，使用eventfd的Channel的来实现。
Muduo分析及总结（五） EventLoop
蜗牛，为梦想而生。
06-29 1004
一、EventLoop 反应器，每个线程一个。用法 muduo::InetAddress listenAddr(9981); muduo::EventLoop loop; muduo::TcpServer server(&loop, listenAddr); server.setConnectionCallback(onConnection); server.setM...
muduo源码分析之EventLoop
Cassie_Yan的博客
07-21 650
muduo源码分析--EventLoop(Channel,Poller,Timer)
Muduo(C++11版本) 源码剖析（二）———EventLoopThread+EventLoopThreadPool设计
苏州-青蛙
08-14 1163
213
muduo源码剖析 - EventLoop
YanWenCheng_的博客
07-07 417
muduo源码剖析
Muduo网络库实战指南
Muduo网络库的手册详细阐述了每个示例的实现原理和代码解析，对于学习和理解如何在实际项目中使用Muduo库非常有帮助。此外，由于Muduo库的开源性质，开发者可以深入源代码，进一步研究其实现细节，提升自己的C++网络...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值