Control的Invoke和BeginInvoke详解

标签：

(一）Control的Invoke和BeginInvoke
我们要基于以下认识：
（1）Control的Invoke和BeginInvoke与Delegate的Invoke和BeginInvoke是不同的。
（2）Control的Invoke和BeginInvoke的参数为delegate，委托的方法是在Control的线程上执行的，也就是我们平时所说的UI线程。

先看一下主线程中调用Invoke和BeginInvoke

我们以代码(一)来看(Control的Invoke)：

private delegate void InvokeDelegate();

private void InvokeMethod(){

   //C代码段

}

private void butInvoke_Click(object sender, EventArgs e) {

   //A代码段.......

   this.Invoke(new InvokeDelegate(InvokeMethod));

   //B代码段......

}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A---------------->C---------------->B
解释：
(1)A在UI线程上执行完后，开始Invoke，Invoke是同步
(2)代码段B并不执行，而是立即在UI线程上执行InvokeMethod方法，即代码段C。
(3)InvokeMethod方法执行完后，代码段B才在UI线程上继续执行。

小结：当在UI线程中执行Invoke时，其实就是函数的直接调用，没什么区别。

private delegate void invokeDelegate();

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    listBox1.Items.Add("--begin--");

    Thread.Sleep(5000);
    this.BeginInvoke(new invokeDelegate(invokeMethod));
    listBox1.Items.Add("--end--");
    workOnUIThread();

}
private void workOnUIThread()
{
    listBox1.Items.Add("--UI--");
}

private void invokeMethod()
{
    listBox1.Items.Add("Invoke:" + Thread.CurrentThread.Name );
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

具体的操作是：我在点击button1后，UI线程sleep5秒钟，在这期间界面会卡死，但是我还是点击两下button2，结果如下：

可以看出执行的顺序是先响应button1的click事件，然后invoke就像函数调用一样，顺序的执行。然后在相应button2的click事件。

看看代码(二)，Control的BeginInvoke：

private delegate void BeginInvokeDelegate();

private void BeginInvokeMethod(){

   //C代码段

}

private void butBeginInvoke_Click(object sender, EventArgs e) {

   //A代码段.......

   this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));

    //这里让线程暂停一下，它同样不会执行C段代码

   Thread.Sleep(1000);

   //B代码段......

}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上。

A----------->B--------------->C

解释：

(1)A在UI线程上执行完后，开始BeginInvoke，BeginInvoke是异步（这个异步在这里没有什么意义，它是相对于支线程异步的，更主线程没什么异步不异步的）
(2)InvokeMethod方法，即代码段C不会执行，而是在UI线程上执行代码段B，即使Sleep一段时间，也不会执行C代码。
(3)代码段B执行完后(就是说butBeginInvoke_Click方法执行完后，并不是什么主线程执行结束后)，InvokeMethod方法，即代码段C才在UI线程上继续执行。

小结：当在UI线程中执行BeginInvoke时，其实是往消息队列发送了一个消息，这个消息告诉UI线程要执行哪个函数。当butBeginInvoke_Click消息处理完成后，OS分配了这个BeginInvoke消息，才去执行相应的函数。

private delegate void invokeDelegate();

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    listBox1.Items.Add("--begin--");
    
    this.BeginInvoke(new invokeDelegate(invokeMethod));
    Thread.Sleep(5000);
    listBox1.Items.Add("--end--");
    workOnUIThread();

}
private void workOnUIThread()
{
    listBox1.Items.Add("--UI--");
}

private void invokeMethod()
{
    listBox1.Items.Add("Invoke:" + Thread.CurrentThread.Name );
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

具体的操作是：我在点击button1后，UI线程sleep5秒钟，在这期间界面会卡死，但是我还是点击两下了button2，结果如下：

可以看出执行的顺序是先响应button1的click事件，然后BeginInvoke执行，把代理函数封装成一个消息，发送的消息队列，等待OS分发消息然后执行。然后UI线程end和UI这两个输出。之后button1的click事件就响应结束了。然后响应BeginInvoke刚封装的消息，最后在相应button2的click事件。

总结：

1. 当在UI线程中执行Invoke时，其实就是函数的直接调用，没什么区别。

2. 当在UI线程中执行BeginInvoke时，其实是往消息队列发送了一个消息，这个消息告诉UI线程要执行哪个函数。当butBeginInvoke_Click消息处理完成后，OS分配了这个BeginInvoke消息，才去执行相应的函数。

还有一点，我们知道：
Control的Invoke和BeginInvoke的委托方法是在主线程，即UI线程上执行的。也就是说如果你的委托方法用来取花费时间长的数据，然后更新界面什么的，千万别在主线程或者支线程上调用Control.Invoke和Control.BeginInvoke，因为这些是依然阻塞UI线程的，造成界面的假死。

我们来看子线程中调用Invoke和BeginInvoke

那么，这个异步到底是什么意思呢?
异步是指相对于调用BeginInvoke的线程异步（一般是支线程调用），而不是相对于UI线程异步，你在UI线程上调用BeginInvoke ，当然不行了。

－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。
BeginInvoke的原理是将调用的方法Marshal成消息，然后调用Win32 API中的RegisterWindowMessage()向UI窗口发送消息。
－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。

立刻总结：上面的这段话是正确的，请相信。那么他的意思就是在支线程中调用Invoke和BeginInvoke，都会把代理函数封装成一个消息，放到消息队列，等待OS分发，然后响应。

(二)我们用Thread来调用BeginInvoke和Invoke
我们开一个线程，让线程执行一些耗费时间的操作，然后再用Control.Invoke和Control.BeginInvoke回到用户UI线程，执行界面更新。
代码(三)  Thread调用Control的Invoke：

private Thread invokeThread;

private delegate void invokeDelegate();

private void StartMethod(){

   //C代码段......

   Control.Invoke(new invokeDelegate(invokeMethod));

  //D代码段......

}

private void invokeMethod(){

  //E代码段

}

private void butInvoke_Click(object sender, EventArgs e) {

   //A代码段.......

   invokeThread = new Thread(new ThreadStart(StartMethod));

   invokeThread.Start();

   //B代码段......

}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A------>(Start一开始B和StartMethod的C就同时执行)---->(C执行完了，不管B有没有执行完，invokeThread把消息封送(invoke)给UI线程，然后自己等待)---->UI线程处理完butInvoke_Click消息后，处理invokeThread封送过来的消息，执行invokeMethod方法，即代码段E，E段代码返回后支线程继续执行D段代码。
这个Control.Invoke是相对于invokeThread线程同步的，阻止了其运行。

解释：
1. UI执行A
2. UI开线程InvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程invokeThread上。
3. invokeThread封送消息给UI，然后自己等待，UI处理完消息后，处理invokeThread封送的消息，即代码段E
4. UI执行完E后，转到线程invokeThread上，invokeThread线程执行代码段D

代码(四)  Thread调用Control的BeginInvoke

private Thread beginInvokeThread;

private delegate void beginInvokeDelegate();

private void StartMethod(){

   //C代码段......

   Control.BeginInvoke(new beginInvokeDelegate(beginInvokeMethod));

  //D代码段......

}

private void beginInvokeMethod(){

  //E代码段

}

private void butBeginInvoke_Click(object sender, EventArgs e) {

   //A代码段.......

   beginInvokeThread = new Thread(new ThreadStart(StartMethod));

   beginInvokeThread .Start();

   //B代码段......

}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A在UI线程上执行----->beginInvokeThread线程开始执行，UI继续执行代码段B，并发地invokeThread执行代码段C-------------->不管UI有没有执行完代码段B，这时beginInvokeThread线程把消息封送给UI，但自己并不等待，继续向下执行-------->UI处理完butBeginInvoke_Click消息后，处理beginInvokeThread线程封送过来的消息。

解释：
1. UI执行A
2. UI开线程beginInvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程beginInvokeThread上。
3. beginInvokeThread封送消息给UI，然后自己继续执行代码D，UI处理完消息后，处理invokeThread封送的消息，即代码段E。

小结：在支线程中调用Invoke和BeginInvoke，都会把代理函数封装成一个消息，放到消息队列，等待OS分发，然后响应。

private delegate void invokeDelegate();

public Form1()

{

    InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

    Thread.CurrentThread.Name = "Main";

    listBox1.Items.Add("--begin--");

    Thread threadInvoke = new Thread(ThreadInvoke);

    threadInvoke.Start();

    Thread.Sleep(5000);

    listBox1.Items.Add("--end--");

    workOnUIThread();

}

private void workOnUIThread()

{

    listBox1.Items.Add("--UI--");

}

private void ThreadInvoke()

{

    this.Invoke(new invokeDelegate(invokeMethod));

    //this.BeginInvoke(new invokeDelegate(invokeMethod));

}

private void button2_Click(object sender, EventArgs e)

{

    listBox1.Items.Add("button2_Click");

}

private void invokeMethod()

{

    listBox1.Items.Add("Invoke:" + Thread.CurrentThread.Name );

}

具体的操作是：我在点击button1后，UI线程sleep5秒钟，在这期间界面会卡死，但是我还是点击两下了button2，结果如下：

可以看出执行的顺序是先响应button1的click事件，然后开启子线程，紧接着UI线程sleep了，子线程继续运行，把代理函数封装成一个消息，挂到UI线程的消息队列中去。等UI线程sleep结束后，继续处理button1的click事件。完了之后，从消息队列中拿到新的消息（就是子线程封装的代理函数），根据消息中指定的代理函数，执行（这些都是UI线程干的活，子线程执行完封装消息就退出了）。处理完这个消息后，再处理button2的click消息。

注意：在子线程中不管调用Invoke或者BeginInvoke，都是封装消息，发送到UI线程的消息队列中去。那么他们的区别是什么？

Invoke会阻塞子线程。

BeginInvoke不会阻塞子线程，它和子线程是异步执行的。

测试代码：

/// <summary>
/// 线程调用Invoke
/// </summary>
private void ThreadInvoke()
{
    listBox1.Items.Add("--begin--");
    new Thread(() =>
    {
        Thread.CurrentThread.Name = "ThreadInvoke";
        string temp = "Before!";
        listBox1.Invoke(new Action(() =>
            {
                Thread.Sleep(10000);
                this.listBox1.Items.Add(temp +="Invoke!" + Thread.CurrentThread.Name);
            }));
        temp += "After!";
    }).Start();
    listBox1.Items.Add("--end--");          
}

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    ThreadInvoke();
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

输出：

• Invoke的委托在主线程中执行
• Invoke在支线程中调用也会阻塞主线程。（当点击button1后，我试图去点击button2，却发现程序被阻塞了）
• Invoke还会阻塞支线程。（因为输出结果中没有出现After）

/// <summary>
/// 线程调用BeginInvoke
/// </summary>
private void ThreadBeginInvoke()
{
    listBox1.Items.Add("--begin--");
    new Thread(() =>
    {
        Thread.CurrentThread.Name = "ThreadBeginInvoke";
        string temp = "Before!";
        listBox1.BeginInvoke(new Action(() =>
        {
            Thread.Sleep(10000);
            this.listBox1.Items.Add(temp += "Invoke!" + Thread.CurrentThread.Name);
        }));
        temp += "After!";
    }).Start();
    listBox1.Items.Add("--end--");
}

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    ThreadBeginInvoke();
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

输出：

• BeginInvoke在主线程中执行。
• BeginInvoke在支线程中调用也会阻塞主线程。
• BeginInvoke相对于支线程是异步的。

上面的这种方法，可以很好的实现把子线程中定义的局部变量传递给UI主线程。

这部分就学习到这里，下面总结一下：

1. 在UI线程中调用Invoke，跟普通的函数调用一样一样的；在UI线程中调用BeginInvoke就是封装消息，挂到UI线程的消息队列中去。

2. 在子线程中调用Invoke和BeginInvoke都是封装消息，挂到主线程的消息队列中去。

3. 在子线程中调用Invoke和BeginInvoke的区别是，子线程会等待Invoke返回再往下继续执行，但是BeginInvoke是同子线程异步执行的，子线程不会等BeginInvoke返回。

Control的Invoke和BeginInvoke详解

标签：

原文地址：http://www.cnblogs.com/stemon/p/4210614.html