`
hyshucom
  • 浏览: 810906 次
文章分类
社区版块
存档分类
最新评论

Chromium MessageLoop类分析

 
阅读更多

原文：

Windows程序是基于消息的，不管其封装形式如何，最后都要包含如下代码

Cpp代码收藏代码
  1. MSGmsg;
  2. while(GetMesssage(&msg))
  3. {
  4. TranslateMessage(&msg);
  5. DispatchMessage(&msg);
  6. }


大部分的工作都是在这个while循环里完成。 GetMessage获得一条消息，然后调用DispatchMessage分发消息。DispatchMessage首先找到消息对应的窗口，调用窗口的消息处理函数，在消息处理函数里通过switch/case执行对应的处理代码，然后返回继续获得下一个消息GetMessage。直到收到WM_QUIT消息，while循环才会退出，否则一直阻塞在GetMessage处等待消息。


一条线程启动后，如果不是进入消息循环，那么很快就结束，比如以下线程入口函数

Cpp代码收藏代码
  1. unsignedintWINAPIThreadFunc(LPVOIDparam)
  2. {
  3. ...
  6. //执行到这里，线程就准备退出了
  7. }


因为创建线程是有代价的，我们希望线程能一直运行，所以加入消息循环，比如


Cpp代码收藏代码
  1. unsignedintWINAPIThreadFunc(LPVOIDparam)
  2. {
  3. ...
  6. while(WaitForMessage())
  7. {
  8. DispatchMessage();
  9. }
  11. }



消息循环就是让线程一直运行在类似的while循环中，不断检查和分发消息，直到收到特定消息而退出循环，然后线程就结束了。




一般来说，除非只为特定工作而创建的线程之外，通用的公共线程都应该有一个消息队列和消息循环。 这样，我们可以通过把消息发送到指定线程的消息队列中，从而让消息在指定线程中处理，而避免多线程访问所带来的并发访问问题。




在Chrome里，是使用MessageLoop对象来封装以上的消息处理循环代码。一条线程在启动后，就会创建MessageLoop对象，并调用MessageLoop.Run()方法来进入消息循环。当MessageLoop.Run()函数返回，即线程退出。


Cpp代码收藏代码
  1. classMessageLoop:publicbase::MessagePump::Delegate{
  2. {
  3. public:
  6. //Runthemessageloop.
  7. voidRun();
  10. //SignalstheRunmethodtoreturnafteritisdoneprocessingallpending
  11. //messages.Thismethodmayonlybecalledonthesamethreadthatcalled
  12. //Run,andRunmuststillbeonthecallstack.
  13. //
  14. //UseQuitTaskifyouneedtoQuitanotherthread'sMessageLoop,butnote
  15. //thatdoingsoisfairlydangerousifthetargetthreadmakesnestedcalls
  16. //toMessageLoop::Run.Theproblembeingthatyouwon'tknowwhichnested
  17. //runloopyouarequiting,sobecareful!
  18. //
  19. voidQuit();
  22. //ReturnstheMessageLoopobjectforthecurrentthread,ornullifnone.
  23. staticMessageLoop*current();
  28. //The"PostTask"familyofmethodscallthetask'sRunmethodasynchronously
  29. //fromwithinamessageloopatsomepointinthefuture.
  30. //
  31. //WiththePostTaskvariant,tasksareinvokedinFIFOorder,inter-mixed
  32. //withnormalUIorIOeventprocessing.
  33. //
  34. //TheMessageLooptakesownershipoftheTask,anddeletesitafterithas
  35. //beenRun().
  36. //
  37. //NOTE:Thesemethodsmaybecalledonanythread.TheTaskwillbeinvoked
  38. //onthethreadthatexecutesMessageLoop::Run().
  41. voidPostTask(consttracked_objects::Location&from_here,Task*task);
  42. }



调用MessageLoop::current()方法可以获得当前线程对应的MessageLoop对象，并可以调用其PostTask方法让该线程上执行一个Task。PostTask把Task放入队列后就返回了，Task会在稍后的消息循环中得到处理。


MessageLoop除了执行Task，还可以处理常规的windows消息以及IO事件等，具体要看MessagLoop的类型。 MessageLoop内部使用使用MessagePump对象来处理消息，并根据不同的类型创建不同的MessagePump。




Cpp代码收藏代码
  1. MessageLoop::MessageLoop(Typetype)
  2. {
  3. lazy_tls_ptr.Pointer()->Set(this);
  6. if(type_==TYPE_DEFAULT){
  7. pump_=newbase::MessagePumpDefault();
  8. }elseif(type_==TYPE_IO){
  9. pump_=newbase::MessagePumpForIO();
  10. }else{
  11. DCHECK(type_==TYPE_UI);
  12. pump_=newbase::MessagePumpForUI();
  13. }
  14. }
  17. voidMessageLoop::RunInternal()
  18. {
  19. pump_->Run(this);
  20. }



MessagePumpDefault最简单，只执行Task。MessagePumpForUI可以处理windows消息队列，而MessagePumpForIO可以处理IO完成端口的消息。不同Pump获得消息的方式是不一样的，MessagePumpDefault等待Event信号量，PumpForUI从Windows的消息队列，而PumpForIO是从IO完成端口。


Cpp代码收藏代码
  1. voidMessagePumpDefault::Run(Delegate*delegate){
  3. if(delayed_work_time_.is_null()){
  4. event_.Wait();
  5. }else{
  6. TimeDeltadelay=delayed_work_time_-Time::Now();
  7. if(delay>TimeDelta()){
  8. event_.TimedWait(delay);
  9. }else{
  10. delayed_work_time_=Time();
  11. }
  12. }
  13. }
  16. voidMessagePumpForUI::WaitForWork(){
  19. DWORDresult;
  20. result=MsgWaitForMultipleObjectsEx(0,NULL,delay,QS_ALLINPUT,
  21. MWMO_INPUTAVAILABLE);
  24. if(WAIT_OBJECT_0==result){
  25. MSGmsg={0};
  26. DWORDqueue_status=GetQueueStatus(QS_MOUSE);
  27. if(HIWORD(queue_status)&QS_MOUSE&&
  28. !PeekMessage(&msg,NULL,WM_MOUSEFIRST,WM_MOUSELAST,PM_NOREMOVE)){
  29. WaitMessage();
  30. }
  31. return;
  32. }
  37. boolMessagePumpForIO::GetIOItem(DWORDtimeout,IOItem*item){
  38. memset(item,0,sizeof(*item));
  39. ULONG_PTRkey=NULL;
  40. OVERLAPPED*overlapped=NULL;
  41. if(!GetQueuedCompletionStatus(port_.Get(),&item->bytes_transfered,&key,
  42. &overlapped,timeout)){
  43. if(!overlapped)
  44. returnfalse;//Nothinginthequeue.
  45. item->error=GetLastError();
  46. item->bytes_transfered=0;
  47. }
  50. item->handler=reinterpret_cast<IOHandler*>(key);
  51. item->context=reinterpret_cast<IOContext*>(overlapped);
  52. returntrue;
  53. }





PostTask只是把Task放在一个Task队列里的，如果这时候线程处于等待消息的阻塞状态，那么还需要发送一条消息去唤醒线程。不同的Pump使用不同的方式，PumpDefault是等待Event信号量，PumpForUI是阻塞在GetMessage上等待Windows消息，所以可以发送Windows消息唤醒。而PumpForIO是阻塞在IO完成端口上，那么只要模拟发送一个IO完成信息过去即可唤醒线程。


Cpp代码收藏代码
  1. voidMessagePumpDefault::ScheduleWork(){
  2. //Sincethiscanbecalledonanythread,weneedtoensurethatourRun
  3. //loopwakesup.
  4. event_.Signal();
  5. }
  8. voidMessagePumpForUI::ScheduleWork(){
  9. PostMessage(message_hwnd_,kMsgHaveWork,reinterpret_cast<WPARAM>(this),0);
  10. }
  13. voidMessagePumpForIO::ScheduleWork(){
  14. BOOLret=PostQueuedCompletionStatus(port_,0,
  15. reinterpret_cast<ULONG_PTR>(this),
  16. reinterpret_cast<OVERLAPPED*>(this));
  17. }




MessagePump对Native消息（Windows消息或IO完成消息）有自己的处理方式（PumpDefault没有消息要处理），而Task则由MessageLoop来统一处理。


Cpp代码收藏代码
  1. voidMessagePumpDefault::Run(Delegate*delegate){
  4. for(;;){
  5. ScopedNSAutoreleasePoolautorelease_pool;
  8. booldid_work=delegate->DoWork();
  9. if(!keep_running_)
  10. break;
  13. if(did_work)
  14. continue;
  17. did_work=delegate->DoIdleWork();
  18. if(!keep_running_)
  19. break;
  22. if(did_work)
  23. continue;
  26. if(delayed_work_time_.is_null()){
  27. event_.Wait();
  28. }else{
  29. TimeDeltadelay=delayed_work_time_-Time::Now();
  30. if(delay>TimeDelta()){
  31. event_.TimedWait(delay);
  32. }else{
  33. //Itlookslikedelayed_work_time_indicatesatimeinthepast,sowe
  34. //needtocallDoDelayedWorknow.
  35. delayed_work_time_=Time();
  36. }
  37. }
  38. //Sinceevent_isauto-reset,wedon'tneedtodoanythingspecialhere
  39. //otherthanserviceeachdelegatemethod.
  40. }
  43. keep_running_=true;
  44. }
  47. voidMessagePumpForUI::DoRunLoop(){
  48. for(;;){
  49. boolmore_work_is_plausible=ProcessNextWindowsMessage();
  50. if(state_->should_quit)
  51. break;
  54. if(more_work_is_plausible)
  55. continue;
  58. more_work_is_plausible=state_->delegate->DoIdleWork();
  59. if(state_->should_quit)
  60. break;
  63. if(more_work_is_plausible)
  64. continue;
  67. WaitForWork();//Wait(sleep)untilwehaveworktodoagain.
  68. }
  69. }
  74. voidMessagePumpForIO::DoRunLoop(){
  75. for(;;){
  76. boolmore_work_is_plausible=state_->delegate->DoWork();
  77. if(state_->should_quit)
  78. break;
  81. more_work_is_plausible|=WaitForIOCompletion(0,NULL);
  82. if(state_->should_quit)
  83. break;
  86. if(more_work_is_plausible)
  87. continue;
  90. more_work_is_plausible=state_->delegate->DoIdleWork();
  91. if(state_->should_quit)
  92. break;
  95. if(more_work_is_plausible)
  96. continue;
  99. WaitForWork();//Wait(sleep)untilwehaveworktodoagain.
  100. }
  101. }


MessageLoop对象从队列里取出Task执行，即调用Task::Run，然后删除。


Cpp代码收藏代码
  1. voidMessageLoop::RunTask(Task*task){
  2. task->Run();
  3. deletetask;
  4. }





当一条线程创建了MessageLoop对象之后，它就具备了运行Task的能力，我们就可以任意指派Task在该线程执行。就像这样


Cpp代码收藏代码
  1. some_message_loop->PostTask(some_task);





因为MessageLoop的本意是处理和分发消息的，是共用，所以消息处理代码不宜运行过长时间，包括Task。因为这会长时间阻塞住整条MessageLoop，影响其它消息的处理。对于需要长时间运行的，还是需要创建单独的工作线程，或者调用异步执行代码。 比如Socket, Pipe和File都是可以用非阻塞的方式操作，即异步IO--在Windows平台上可以使用IO完成端口来方便处理。MessageLoopForIO可以用于异步IO专用线程，调用者只有把IO对象的句柄交给MessageLoopForIO对象（MessagePumpForIO ::RegisterIOHandler），以后每当有IO对象的操作完成时，调用者就会从MessageLoopForIO收到回调通知（IOHandler::OnIOCompleted）。 MessageLoopForUI就更不用说了，因为Windows窗口是绑定到创建线程上的，所以只要有一个MessageLoopForUI对象就可以处理属于该线程的所有Windows消息，不需要额外的注册过程。


Cpp代码收藏代码
  1. classMessagePumpForIO:publicMessagePumpWin{
  4. classIOHandler{
  5. public:
  6. virtual~IOHandler(){}
  7. //ThiswillbecalledoncethependingIOoperationassociatedwith
  8. //|context|completes.|error|istheWin32errorcodeoftheIOoperation
  9. //(ERROR_SUCCESSiftherewasnoerror).|bytes_transfered|willbezero
  10. //onerror.
  11. virtualvoidOnIOCompleted(IOContext*context,DWORDbytes_transfered,
  12. DWORDerror)=0;
  13. };
  18. voidRegisterIOHandler(HANDLEfile_handle,IOHandler*handler);
  21. }



所以，如果相关模块都可以异步调用，那么只要有两条线程（分别处理UI和IO消息）即可满足程序的需要，而主线程一般就是UI线程。 使用基于MessageLoop的消息分发机制，可以大大减少线程的数量，避免程序并发带来的各种问题。

分享到：
| chromium消息循环机制
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics