muduo網路庫學習之EventLoop（二）：程式（執行緒）wait/notify 和 EventLoop::runInLoop

1
2
3
4

wakeupChannel_->setReadCallback(
    boost::bind(&EventLoop::handleRead, this));
// we are always reading the wakeupfd
wakeupChannel_->enableReading();

1
2

typedef boost::function<void()> Functor;
std::vector<Functor> pendingFunctors_;

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// 事件迴圈，該函式不能跨執行緒呼叫
// 只能在建立該物件的執行緒中呼叫
void EventLoop::loop()
{// 斷言當前處於建立該物件的執行緒中
  assertInLoopThread();
    while (!quit_)
    {
        pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);

        eventHandling_ = true;
        for (ChannelList::iterator it = activeChannels_.begin();
                it != activeChannels_.end(); ++it)
        {
            currentActiveChannel_ = *it;
            currentActiveChannel_->handleEvent(pollReturnTime_);
        }
        currentActiveChannel_ = NULL;
        eventHandling_ = false;
        doPendingFunctors();
    }
}

// 為了使IO執行緒在空閒時也能處理一些計算任務
// 在I/O執行緒中執行某個回撥函式，該函式可以跨執行緒呼叫
void EventLoop::runInLoop(const Functor& cb)
{
  if (isInLoopThread())
  {
    // 如果是當前IO執行緒呼叫runInLoop，則同步呼叫cb
    cb();
  }
  else
  {
    // 如果是其它執行緒呼叫runInLoop，則非同步地將cb新增到佇列,讓IO執行緒處理
    queueInLoop(cb);
  }
}

void EventLoop::queueInLoop(const Functor& cb)
{
  {
  MutexLockGuard lock(mutex_);
  pendingFunctors_.push_back(cb);
  }

  // 呼叫queueInLoop的執行緒不是當前IO執行緒則需要喚醒當前IO執行緒，才能及時執行doPendingFunctors();

  // 或者呼叫queueInLoop的執行緒是當前IO執行緒（比如在doPendingFunctors()中執行functors[i]() 時又呼叫了queueInLoop()）

  // 只有當前IO執行緒的事件回撥中呼叫queueInLoop才不需要喚醒

 //  即在handleEvent()中呼叫queueInLoop 不需要喚醒，因為接下來馬上就會執行doPendingFunctors();
  if (!isInLoopThread() || callingPendingFunctors_)
  {
    wakeup();
  }
}

// 該函式只會被當前IO執行緒呼叫
void EventLoop::doPendingFunctors()
{
  std::vector<Functor> functors;
  callingPendingFunctors_ = true;

  {
  MutexLockGuard lock(mutex_);
  functors.swap(pendingFunctors_);
  }

  for (size_t i = 0; i < functors.size(); ++i)
  {
    functors[i]();
  }
  callingPendingFunctors_ = false;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 該函式可以跨執行緒呼叫
TimerId TimerQueue::addTimer(const TimerCallback &cb,
                             Timestamp when,
                             double interval)
{
    Timer *timer = new Timer(cb, when, interval);

    loop_->runInLoop(   // addTimeInLoop 只能在當前IO執行緒呼叫
        boost::bind(&TimerQueue::addTimerInLoop, this, timer));

    return TimerId(timer, timer->sequence());
}
// 該函式可以跨執行緒呼叫
void TimerQueue::cancel(TimerId timerId)
{
    loop_->runInLoop(   // cancelInLoop 只能在當前IO執行緒呼叫
        boost::bind(&TimerQueue::cancelInLoop, this, timerId));
}