从webrtc的Thread::Invoke谈起

 好久没有读代码，有些生疏。就好奇，好奇心浪费了不少时间。
 我对webrtc中Thread::Invoke很感兴趣。

//invoke_test.cc
#include "rtc_base/thread.h"
#include "rtc_base/bind.h"
#include "rtc_base/location.h"
#include <stdio.h>
class Callback{
public:
    Callback(){}
    ~Callback(){}
    void Print(){
    rtc::Thread *thread=rtc::Thread::Current();
    printf("callback %p\n",thread);    
    }  
};
int main(){
    rtc::Thread worker;
    rtc::Thread *thread=rtc::Thread::Current();
    printf("main %p\n",thread);
    worker.Start();
    Callback test;
    worker.Invoke<void>(RTC_FROM_HERE,rtc::Bind(&Callback::Print,&test));
    
    printf("worker %p\n",&worker);
    
    worker.Stop();
    return 0;
}

 这个代码是可以测试的，无需去编译webrtc的庞大的代码库，已经有人帮你预编译好了库[1]。编译这个测试程序使用的CMakeLists.txt如下：

PROJECT(project)
cmake_minimum_required(VERSION 2.6)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -Wall  -O2")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -O2")
if (CMAKE_SYSTEM_NAME MATCHES "Windows")
	add_definitions(-DWEBRTC_WIN)
elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
	add_definitions(-DWEBRTC_POSIX -DWEBRTC_LINUX)
endif()
SET(CMAKE_BUILD_TYPE "Debug")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -Wall  -O2")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -O2")
set(CMAKE_CXX_FLAGS "-fPIC")  
set(CMAKE_C_FLAGS "-fPIC") 
add_definitions(-D__STDC_FORMAT_MACROS)
#add_definitions(-DNDEBUG)
add_definitions(-std=c++11  )#-fno-rtti
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
include_directories(${CMAKE_SOURCE_DIR}/webrtc/include/)
LINK_DIRECTORIES(${CMAKE_SOURCE_DIR}/webrtc/lib/x64/Release)
set(EXECUTABLE_NAME "invoke")
add_executable(${EXECUTABLE_NAME} invoke_test.cc)
target_link_libraries(${EXECUTABLE_NAME}  webrtc_full pthread)

 我困惑的就是invoke是怎么阻塞在哪里，直到回调函数被执行的。

void Thread::Send(const Location& posted_from,
                  MessageHandler* phandler,
                  uint32_t id,
                  MessageData* pdata) {
  // Sent messages are sent to the MessageHandler directly, in the context
  // of "thread", like Win32 SendMessage. If in the right context,
  // call the handler directly.
  Message msg;
  msg.posted_from = posted_from;
  msg.phandler = phandler;
  msg.message_id = id;
  msg.pdata = pdata;
  if (IsCurrent()) {
    phandler->OnMessage(&msg);
    return;
  }

  AssertBlockingIsAllowedOnCurrentThread();

  AutoThread thread;
  Thread *current_thread = Thread::Current();
  RTC_DCHECK(current_thread != nullptr);  // AutoThread ensures this

  bool ready = false;
  {
    CritScope cs(&crit_);
    _SendMessage smsg;
    smsg.thread = current_thread;
    smsg.msg = msg;
    smsg.ready = &ready;
    sendlist_.push_back(smsg);//①
  }

  // Wait for a reply
  WakeUpSocketServer();

  bool waited = false;
  crit_.Enter();
  while (!ready) {
    crit_.Leave();
    // We need to limit "ReceiveSends" to |this| thread to avoid an arbitrary
    // thread invoking calls on the current thread.
    current_thread->ReceiveSendsFromThread(this);//②
    current_thread->socketserver()->Wait(kForever, false);
    waited = true;
    crit_.Enter();
  }
  crit_.Leave();                  
 }
 void Thread::ReceiveSendsFromThread(const Thread* source){
   crit_.Enter();
  while (PopSendMessageFromThread(source, &smsg)) {
    crit_.Leave();

    smsg.msg.phandler->OnMessage(&smsg.msg);

    crit_.Enter();
    *smsg.ready = true;
    smsg.thread->socketserver()->WakeUp();
  }
  crit_.Leave();
 }
 bool Thread::PopSendMessageFromThread(const Thread* source, _SendMessage* msg) {
 //③
  for (std::list<_SendMessage>::iterator it = sendlist_.begin();
       it != sendlist_.end(); ++it) {
    if (it->thread == source || source == nullptr) {
      *msg = *it;
      sendlist_.erase(it);
      return true;
    }
  }
  return false;
}

 rtc::Bind的函数最终被封装到_SendMessage，并push到 sendlist_，但是标号①的sendlist_，和通过标号②进入PopSendMessageFromThread函数处理的sendlist_，明显不在同一个Thread的实例中。于是我就困惑了， current_thread是怎么处理标号①中的sendlist_。在这里耗了一个下午，加上一个晚上，并请教了一个好友。没有解决，知道在Thread里打印出一些地址，才解决。current_thread是不处理处理标号①中的sendlist_，这是毫无疑问的。只是MessageQueue会调用Thread::ReceiveSends()来处理本线程里的sendlist_。

bool MessageQueue::Get(Message *pmsg, int cmsWait, bool process_io) {
  while (true) {
    // Check for sent messages
    ReceiveSends();
    }
}

 另外这句代码current_thread->ReceiveSendsFromThread(this)，还是很重要的。防止死锁的情况，将this表示的线程invoke的发送的回调函数先执行掉。比如，这个current_thread是确实一个创建的线程，有实际的处理任务，如果this表示的Thread线程也向worker线程invoke任务，this阻塞，等待worker执行任务，这个时候current_thread向this线程invoke任务，如果缺少那一句current_thread->ReceiveSendsFromThread(this)，就可能出现死锁。

 完！！！！
[1] webrtc prebuilt library https://sourcey.com/precompiled-webrtc-libraries