正文

C# Control.BeginInvoke、synchronizationcontext.post、delegate.BeginInvoke的运行原理

IP云
IP云V管理员/2 阅读
12/02
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

背景

用到的知识点

1、windows消息机制

备注：鼠标点击、键盘等事件产生的消息要放入系统消息队列，然后再分配到应用程序线程消息队列。软件PostMessage的消息直接进入应用程序线程消息队列，不需要经过系统消息队列。软件SendMessage()的消息直接进入 DispatchMessage （）。

实现sendmessage发送消息的接收，在消息的接收方，覆写DefWindowProc()，在该方法中即可接收到sendmessage方法发送来的消息。因为sendmessage发送的消息，不再经过消息队列，而是直接发送给指定对象。所以一般的消息响应，包括PreTranslateMessage方法都无法接收到该信息，只能通过覆写DefWindowProc方法，来接收信息。

  1. 鼠标点击按钮（也是窗体）。
  2. 操作系统底层获知这次点击动作，根据点击位置遍历找到对应的Hwnd 句柄，构建一个Window消息MSG，把这个消息加入全局消息队列。
  3. 操作系统全局消息队列调度器，又将消息分配到创建该Hwnd线程的消息队列中去。
  4. 应用程序主线程处于GetMessage循环中，每次调用GetMessage获取一个消息，如果线程的消息队列为空，则线程会被挂起，直到线程消息队列存在消息线程会被重新激活。调用DispatchMessage分发消息MSG，MSG持有一个Hwnd的字段，指明了消息应该发往的Hwnd，操作系统在第2步构建MSG时会设置这个值。
  5. 消息被发往Hwnd，操作系统回调该Hwnd对应的窗口过程WndProc，由WndProc来处理这个消息。

这是一个简略的Window消息处理流程，往具体说这个故事会很长，让我们把目光收回到WPF，看看WPF和即将介绍的Dispatcher在这个基础上都做了些什么，又有哪些出彩的地方。

2、【windows 操作系统】什么是窗口？|按钮也是窗口

3、【windows 操作系统】窗口指针 和 窗口句柄 有什么区别。句柄是执行指针的指针。

4、消息与消息队列

Windows 操作系统是基于事件驱动的一种操作系统，所以在Windows平台下所有应用程序也是基于事件驱动机制，即是基于消息的。例如，当用户在窗口中按下鼠标左键时，操作系统会知晓这一事件，于是将事件封装成一个消息，传递到应用程序的消息队列中，，然后应用程序从消息队列中取出消息并进行响应。在这个处理过程中，操作系统会调用应用程序中专门负责消息处理的函数，该函数称为窗口过程。

5、C++窗口的程序 ： 

#include <stdio.h>

#include <windows.h>

#include <stdexcept>

using namespace std;

//回调函数原型声明,返回长整形的结果码,CALLBACK是表示stdcall调用LRESULT CALLBACK WinProc(

                            HWND hwnd,      // handle to window

                            UINT uMsg,      // message identifier

                            WPARAM wParam,  // first message parameter

                            LPARAM lParam   // second message parameter

);

//(1) WinMain函数,程序入口点函数

int WINAPI WinMain(

                   HINSTANCE hInstance,      // handle to current instance

                   HINSTANCE hPrevInstance,  // handle to previous instance

                   LPSTR lpCmdLine,          // command line

                   int nCmdShow              // show state

                   ){

    //(2)

    //一.设计一个窗口类,类似填空题,使用窗口结构体

    WNDCLASS wnd;

    wnd.cbClsExtra = 0; //类的额外内存

    wnd.cbWndExtra = 0;    //窗口的额外内存

    wnd.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);//创建一个空画刷填充背景

    //加载游标,如果是加载标准游标,则第一个实例标识设置为空

    wnd.hCursor = LoadCursor(NULL, IDC_CROSS);

    wnd.hIcon = LoadIcon(NULL, IDI_ERROR);

    wnd.hInstance = hInstance;//实例句柄赋值为程序启动系统分配的句柄值

    wnd.lpfnWndProc = WinProc;//消息响应函数

    wnd.lpszClassName = "gaojun";//窗口类的名子,在注册时会使用到

    wnd.lpszMenuName = NULL;//默认为NULL没有标题栏

    wnd.style = CS_HREDRAW | CS_VREDRAW;//定义为水平和垂直重画

    //二.注册窗口类

    RegisterClass(&wnd);

    //三.根据定制的窗口类创建窗口

    HWND hwnd;//保存创建窗口后的生成窗口句柄用于显示

    //如果是多文档程序,则最后一个参数lParam必须指向一个CLIENTCREATESTRUCT结构体

    hwnd = CreateWindow("gaojun", "WIN32应用程序", WS_OVERLAPPEDWINDOW,

 CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hInstance, NULL);

    //四.显示窗口

    ShowWindow(hwnd, SW_SHOWDEFAULT);

    //五.更新窗口

    UpdateWindow(hwnd);

    //(3).消息循环

    MSG msg;//消息结构体

    //如果消息出错,返回值是-1,当GetMessage从消息队列中取到是WM_QUIT消息时,返回值是0

    //也可以使用PeekMessage函数从消息队列中取出消息

    BOOL bSet;

    while((bSet = GetMessage(&msg, NULL, 0, 0)) != 0){

        if (-1 ==  bSet)

        {

            return -1;

        }

        else{

            TranslateMessage(&msg);

            DispatchMessage(&msg);

        }

    }

    return 0;//程序结束,返回0

}

//消息循环中对不同的消息各类进行不同的响应

LRESULT CALLBACK WinProc(

                         HWND hwnd,      // handle to window

                         UINT uMsg,      // message identifier

                         WPARAM wParam,  // first message parameter

                         LPARAM lParam   // second message parameter

                         ){

    switch (uMsg)

    {

    case WM_CHAR://字符按键消息

        char szChar[20];

        sprintf(szChar, "char is %d;", wParam);//格式化操作,stdio.h

        MessageBox(hwnd, szChar, "gaojun", 0);//输出操作windows.h中

        break;

    case WM_LBUTTONDOWN://鼠标左键按下消息

        MessageBox(hwnd, "this is click event!", "点击", 0);

        HDC hdc;

        hdc = GetDC(hwnd);//获取设备上下文句柄,用来输出文字

        //在x=0,y=50(像素)的地方输出文字

        TextOut(hdc, 0, 50, "响应WM_LBUTTONDONW消息!",

strlen("响应WM_LBUTTONDONW消息!"));

        ReleaseDC(hwnd, hdc);//在使用完DC后一定要注意释放

        break;

    case WM_PAINT://窗口重给时报消息响应

        HDC hDc;

        PAINTSTRUCT ps;

        hDc = BeginPaint(hwnd, &ps);

        TextOut(hDc, 0, 0, "这是一个Paint事件!", strlen("这是一个Paint事件!"));

        EndPaint(hwnd, &ps);

        break;

    case WM_CLOSE://关闭消息

        if (IDYES == MessageBox(hwnd, "确定要关闭当前窗口?", "提示", MB_YESNO))

        {

            DestroyWindow(hwnd);//销毁窗口

        }

        break;

    case WM_DESTROY:

        PostQuitMessage(0);//在响应消息后,投递一个退出的消息使用程序安全退出

        break;

    default:

        return DefWindowProc(hwnd, uMsg, wParam, lParam);//调用缺省的消息处理过程函数

    }

    return 0;

}

备注：消息的接收主要有3个函数： GetMessage、PeekMessage、WaitMessage 。

PeekMessage 从进程的主线程的消息队列中获取一个消息 如果队列中没有消息就直接返回。 

while(true)

{

    if(PeekMessage(&msg, m_hWnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))

    {

        if (msg.message == WM_QUIT)

        {

            break;

        }

        if(msg.message == WM_KEYDWON && msg.wParam == VK_ESCAPE)

        {

            ...

        }

    }

    else

    {

        // no message

    }

}

GetMessage 从进程的主线程的消息队列中获取一个消息并将它复制到MSG结构，如果队列中没有消息，则GetMessage函数将等待一个消息的到来以后才返回。如果你将一个窗口句柄作为第二个参数传入GetMessage，那么只从队列中获得指定窗口的的消息。 

while(GetMessage(&msg, NULL, 0, 0))

{

if(!TranslateAccelerator(msg.hWnd, hAccelTable, &msg))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}

DispatchMessage 会调用到SendMessage(),
SendMessage 函数的运行机制，综述为，SendMessage 内部调用 SendMessageW、SendMessageWorker 函数做内部处理，然后调用UserCallWinProcCheckWow、InternalCallWinProc 来调用我们代码中的消息处理函数，消息处理函数完成之后，SendMessage 函数便返回了。

（1)创建窗口过程函数（WinProc:Windows procedure）函数。该还是个回调函数。

窗口过程函数： 一个窗体对象都使用 窗体过程函数（WindowProc） 来处理接收到的各种消息。 

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    PAINTSTRUCT ps;

    HDC hdc;

    switch (message)

    {

    case WM_COMMAND:

        break;

    case WM_PAINT:

        hdc = BeginPaint(hWnd, &ps);

        // TODO: 在此添加任意绘图代码...

        EndPaint(hWnd, &ps);

        break;

    case WM_DESTROY:

        PostQuitMessage(0);

        break;

    default:

        return DefWindowProc(hWnd, message, wParam, lParam);

    }

    return 0;

}

备注： DispatchMessage 会调用到SendMessage(),
SendMessage
函数的运行机制，综述为，SendMessage 内部调用 SendMessageW、SendMessageWorker
函数做内部处理，然后调用UserCallWinProcCheckWow、InternalCallWinProc
来调用我们代码中的消息处理函数，消息处理函数完成之后，SendMessage 函数便返回了。

(2)定义一个窗口类，将回调函数WinProc做参数传给 窗口类。
针对Windows的消息处理机制，窗口过程函数被调用的过程如下:
在设计窗口类的时候，将窗口赛程函数的地址赋值给lpfnWndProc成员变量
调用RegisterClass(&wndclass)注册窗口类，那么系统就有了我们所编写的窗口过程函数的地址
当应用程序接收到某一窗口的消息，调用DispatchMessage(&msg)将消息加值给系统。系统则利用先前注册窗口类时得到函数指针，调用窗口过程函数对消息进行处理。
(3)注册窗口类RegisterClass(&wnd);
RegisterClass函数的作用是通知系统，你要定义一个新的窗体类型，然后把这个类型记录到系统里面，以后你就可以使用CreateWindow来创建一个基于此类型的窗体。基于此类型的    窗体都具有相同的属性，比如，背景色，光标，图标等等。在MFC中，对于　　　　　　对话框而言，系统已经注册了对话框自己的类型，因此你无需调用RegisterClass就可以使用自带的对话框类    创建模态或者非模态窗口。
(4)实例化 窗口类。
(5)显示窗口 ShowWindow(hwnd, SW_SHOWDEFAULT);
(6)更新窗口 UpdateWindow(hwnd);

SendMessage与PostMessage的运行原理

在了解完windows的消息机制。我们再看他的应用。

备注：鼠标点击、键盘等事件产生的消息要放入系统消息队列，然后再分配到应用程序线程消息队列。软件PostMessage的消息直接进入应用程序线程消息队列，不需要经过系统消息队列。软件SendMessage()的消息直接进入 DispatchMessage （）。

PostMessaget() 对应的是队列消息，PostMessage是Windows API(应用程序接口) 中的一个常用函数，用于将一条消息直接放入到应用程序线程消息队列中（不经过系统消息队列）。该函数将一个消息放入（寄送）到与指定窗口创建的线程相联系消息队列里，不等待线程处理消息就返回，是异步消息模式。消息队列里的消息通过调用GetMessage和PeekMessage取得。把消息投递到消息队列后，立即返回；

SendMessage() 对应的是非队列消息，SendMessage是Windows API(应用程序接口) 中的一个常用函数，它把消息直接送到 窗口，winpro函数 处理完 SendMessage() 就返回了。 实现sendmessage发送消息的接收，在消息的接收方，覆写DefWindowProc()，在该方法中即可接收到sendmessage方法发送来的消息。因为sendmessage发送的消息，不再经过消息队列，而是直接发送给指定对象。所以一般的消息响应，包括PreTranslateMessage方法都无法接收到该信息，只能通过覆写DefWindowProc方法，来接收信息。该函数将指定的消息发送到一个或多个窗口。此函数为指定的窗口调用窗口程序，直到窗口程序处理完消息再返回。而和函数PostMessage不同，PostMessage是将一个消息寄送到一个线程的消息队列后就立即返回。

DispatchMessage 会调用到SendMessage(),
SendMessage
函数的运行机制，综述为，SendMessage 内部调用 SendMessageW、SendMessageWorker
函数做内部处理，然后调用UserCallWinProcCheckWow、InternalCallWinProc
来调用我们代码中的消息处理函数，消息处理函数完成之后，SendMessage 函数便返回了。 

LRESULT SendMessage（HWND hWnd，UINT Msg，WPARAM wParam，LPARAM IParam）

hWnd：其窗口程序将接收消息的窗口的句柄。如果此参数为HWND_BROADCAST，则消息将被发送到系统中所有顶层窗口，包括无效或不可见的非自身拥有的窗口、被覆盖的窗口和弹出式窗口，但消息不被发送到子窗口。Msg：指定被发送的消息。

wParam：指定附加的消息特定信息。

IParam：指定附加的消息特定信息。

返回值：返回值指定消息处理的结果，依赖于所发送的消息。

Control.BeginInvoke and Control.Invoke 
public IAsyncResult BeginInvoke(Delegate method, params object[] args)

{

  using (new MultithreadSafeCallScope())

  {

    return (IAsyncResult) this.FindMarshalingControl().MarshaledInvoke(this, method, args, false);

  }

}

public object Invoke(Delegate method, params object[] args)

{

  using (new MultithreadSafeCallScope()){

    return this.FindMarshalingControl().MarshaledInvoke(this, method, args, true);

  }

}

这里的 FindMarshalingControl 方法通过一个 循环向上回溯 ，从当前控件开始回溯父控件，直到找到最顶级的父控件，用它作为封送对象。例如，我们调用窗体上一个进度条的Invoke方法封送委托，但是实际上会回溯到主窗体，通过这个控件对象来封送委托。因为主窗体是主线程消息队列相关的，发送给主窗体的消息才能发送到界面主线程消息队列。

我们可以看到Invoke和BeginInvoke方法使用了同样的实现，只是MarshaledInvoke方法的最后一个参数值不一样。

MarshaledInvoke 

private object MarshaledInvoke(Control caller, Delegate method, object[] args, bool synchronous)

{

  int num;

  if (!this.IsHandleCreated)

  {

    throw new InvalidOperationException(SR.GetString("ErrorNoMarshalingThread"));

  }

  if (((ActiveXImpl) this.Properties.GetObject(PropActiveXImpl)) != null)

  {

    IntSecurity.UnmanagedCode.Demand();

  }

  bool flag = false;

  if ((SafeNativeMethods.GetWindowThreadProcessId(new HandleRef(this, this.Handle), out num) == SafeNativeMethods.GetCurrentThreadId()) && synchronous)

  {

    flag = true;

  }

  ExecutionContext executionContext = null;

  if (!flag)

  {

    executionContext = ExecutionContext.Capture();

  }

  ThreadMethodEntry entry = new ThreadMethodEntry(caller, method, args, synchronous, executionContext);

  lock (this)

  {

    if (this.threadCallbackList == null)

    {

      this.threadCallbackList = new Queue();

    }

  }

  lock (this.threadCallbackList)

  {

    if (threadCallbackMessage == 0)

    {

      threadCallbackMessage = SafeNativeMethods.RegisterWindowMessage(Application.WindowMessagesVersion + "_ThreadCallbackMessage");

    }

    this.threadCallbackList.Enqueue(entry);

  }

  if (flag)

  {

    this.InvokeMarshaledCallbacks();

  }

  else

  {

   //终于找到你了，

    PostMessageUnsafeNativeMethods.PostMessage(new HandleRef(this, this.Handle), threadCallbackMessage, IntPtr.Zero, IntPtr.Zero);

  }

  if (!synchronous)

  //如果是异步，那么马上返回吧

  {

    return entry;

  }

  if (!entry.IsCompleted)

  //同步调用没结束，阻塞起来等待吧

  {

    this.WaitForWaitHandle(entry.AsyncWaitHandle);

  }

  if (entry.exception != null)

  {

    throw entry.exception;

  }

  return entry.retVal;

}

怎么样，我们终于看到 PostMessage 了吧？通过windows消息机制实现了封送。而需要封送的委托方法作为消息的参数进行了传递。关于其它的代码这里不作进一步解释。

InvokeRequired 

public bool InvokeRequired

{

  get

  {

    using (new MultithreadSafeCallScope())

    {

      HandleRef ref2;

      int num;

      if (this.IsHandleCreated)

      {

        ref2 = new HandleRef(this, this.Handle);

      }

      else

      {

        Control wrapper = this.FindMarshalingControl();

        if (!wrapper.IsHandleCreated)

        {

          return false;

        }

        ref2 = new HandleRef(wrapper, wrapper.Handle);

      }

      int windowThreadProcessId = SafeNativeMethods.GetWindowThreadProcessId(ref2, out num);

      int currentThreadId = SafeNativeMethods.GetCurrentThreadId();

      return (windowThreadProcessId != currentThreadId);

    }

  }

}

终于看到了，这是在判断windows窗体线程和当前的调用者线程是否是同一个，如果是同一个就没有必要封送了，直接访问这个GUI控件吧。否则，就不要那么直接表白了，就需要 Invoke 或者 BeginInvoke 做媒了。

Control.BeginInvoke winform的运行原理同上-- 线程外操作GUI控件的问题

WinForm提供了 WindowsFormSynchronizationContext 类，该类重写了同步上下文的 Post 方法来调用 Control.BeginInvoke 。

如果从另外一个线程操作windows窗体上的控件，就会和主线程产生竞争，造成不可预料的结果，甚至死锁。因此windows GUI编程有一个规则，就是只能通过创建控件的线程来操作控件的数据，否则就可能产生不可预料的结果。

因此，dotnet里面，为了方便地解决这些问题，Control类实现了ISynchronizeInvoke接口，提供了Invoke和BeginInvoke方法来提供让其它线程更新GUI界面控件的机制。 

public interface ISynchronizeInvoke

  {

         [HostProtection(SecurityAction.LinkDemand, Synchronization=true, ExternalThreading=true)]

          IAsyncResult BeginInvoke(Delegate method, object[] args);

         object EndInvoke(IAsyncResult result);

        object Invoke(Delegate method, object[] args);

        bool InvokeRequired { get; }

 }

Dispatcher.BeginInvoke WPF 原理同上

绑定wpf 框架。WPF提供了 DispatcherSynchronizationContext 类，该类重写同步上下文的 Post 方法来调用 Dispatcher.BeginInvoke

synchronizationcontext 的send()\post()方法 原理同上

使用 SynchronizationContext ，而不需要将其绑定到特定框架。 SynchronizationContext 提供了一个虚 Post 方法，该方法只接收一个委托，并在任何地点，任何时间运行它，当然 SynchronizationContext 的实现要认为是合适的。

Delegate.BeginInvoke

通过一个委托来进行同步方法的异步调用，也是.net提供的异步调用机制之一。但是 Delegate.BeginInvoke 方法是从ThreadPool取出一个线程来执行这个方法，以获得异步执行效果的。也就是说，如果采用这种方式提交多个异步委托，那么这些调用的顺序无法得到保证。而且由于是使用线程池里面的线程来完成任务，使用频繁，会对系统的性能造成影响。

Delegate.BeginInvoke 也是讲一个委托方法封送到其它线程，从而通过异步机制执行一个方法。调用者线程则可以在完成封送以后去继续它的工作。但是这个方法封送到的最终执行线程是运行库从ThreadPool里面选取的一个线程。

这里需要纠正一个误区，那就是Control类上的异步调用BeginInvoke并没有开辟新的线程完成委托任务，而是让界面控件的所属线程完成委托任务的。看来异步操作就是开辟新线程的说法不一定准确。

https://www.cnblogs.com/Zhouyongh/archive/2011/01/12/1933414.html

相关阅读

目录[+]