muduo网络库学习之EventLoop（四）：EventLoopThread 类、EventLoopThreadPool 类

最新推荐文章于 2024-07-24 17:16:57 发布

s1mba

最新推荐文章于 2024-07-24 17:16:57 发布

阅读量5.5k

点赞数 3

分类专栏： muduo网络库学习文章标签： muduo EventLoopThread EventLoopThreadpool

本文链接：https://blog.csdn.net/jnu_simba/article/details/14519409

版权

本文介绍了muduo网络库中的EventLoopThread和EventLoopThreadPool。EventLoopThread封装了IO线程，用于创建和运行EventLoop。EventLoopThreadPool则是IO线程池，管理多个IO线程。通过示例代码和测试输出，展示了如何在IO线程中执行任务，以及线程池如何处理并发连接。文章强调了主线程与IO线程的区别，并讨论了线程间协作的细节，如线程唤醒和事件循环的退出机制。

摘要由CSDN通过智能技术生成

1、EventLoopThread（IO线程类）

任何一个线程，只要创建并运行了EventLoop，都称之为IO线程

IO线程不一定是主线程

muduo并发模型one loop per thread + threadpool（计算线程池）

为了方便今后使用，定义了EventLoopThread类，该类封装了IO线程

EventLoopThread创建了一个线程

在线程函数中创建了一个EvenLoop对象并调用EventLoop::loop

多个IO线程可以用IO线程池来管理，对应的类是EventLoopThreadPool

     C++ Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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

    EventLoopThread( const ThreadInitCallback &cb = ThreadInitCallback());
    ~EventLoopThread();

    EventLoop *startLoop() // 启动线程，该线程就成为了IO线程
    {
        thread_.start(); // 执行threadFunc(); 构造函数初始化列表中thread_(boost::bind(&EventLoopThread::threadFunc, this))
        ....
    };

private:
     void threadFunc();       // 线程函数

    EventLoop *loop_;            // loop_指针指向一个EventLoop对象
     bool exiting_;
    Thread thread_;
    MutexLock mutex_;
    Condition cond_;
    ThreadInitCallback callback_;        // 回调函数在EventLoop::loop事件循环之前被调用
};

EventLoopThread::~EventLoopThread()
{
    exiting_ = true;
    loop_->quit();       // 退出IO线程，让IO线程的loop循环退出，从而退出了IO线程
    thread_.join();
}

C++ Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

EventLoop *EventLoopThread::startLoop()
{
    assert(!thread_.started());
    thread_.start(); //启动线程，此时有两个线程在运行，
     //一个是调用EventLoopThread::startLoop()的线程，一个是执行EventLoopThread::threadFunc()的线程（IO线程）
    {
        MutexLockGuard lock(mutex_);
         while (loop_ == NULL)
        {
            cond_.wait(); //函数返回loop_，所以要等待IO线程启动
        }
    }

     return loop_;
}

void EventLoopThread::threadFunc()
{
    EventLoop loop;

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

    {
        MutexLockGuard lock(mutex_);
         // 一般情况是EventLoopThread对象先析构，析构函数调用loop_->quit() 使得loop.loop() 退出循环
         // 这样threadFunc 退出，loop栈上对象析构，loop_ 指针失效，但此时已经不会再通过loop_ 访问loop，
         // 故不会有问题。
        loop_ = &loop;
        cond_.notify();
    }

    loop.loop();
     //assert(exiting_);
}

测试代码：