多线程笔记一

一、多线程使用场景
1. 后台循环任务，少量UI更新：例如批量上传文件，并提供进度。这种情况使用BackgroundWorker组件是非常好的选择。
2. 耗时的后台任务：这里的耗时任务是指一个时间较长的任务，并且不能精确获取进度，
如：调用一个远程WebService接口。这种情况可以开两个线程，一个工作，一个更新UI（不能提供进度，只能显示动画表示系统在运行中）。
代码示例：
在后台执行一个不可分解的耗时任务，需要进行界面更新，以便让客户看上去程序有所响应。这种情况下，UI线程一般也不知道工作线程何时结束，所以一般执行循环任务，当工作线程结束后，关闭UI线程就可以了。
Thread uithread = null;
private void btnStart_Click(object sender, EventArgs e)
{
    uithread = new Thread(new ThreadStart(this.UpdateProgressThread));
    uithread.Start();
    Thread workthread = new Thread(new ThreadStart(this.DoSomething));
    workthread.Start();
}

private void DoSomething()
{
    Thread.Sleep(5000);
    uithread.Abort();
    MessageBox.Show("work end");
}

private void UpdateProgressThread()
{
    for (int i = 0; i < 10000; i++)
    {
        Thread.Sleep(100);
        this.Invoke(new Action<int>(this.UpdateProgress), i);
    }
}

private void UpdateProgress(int v)
{
    this.progressBar1.Value = v;
}

3.耗时的UI任务：当工作压力集中在UI响应上时，可以在工作者线程中增加延时，从而让UI线程获得响应时间。整个工作的总体时间会增加，但用户响应效果会好很多。
private void FormInitForm_Load(object sender, EventArgs e)
{
    this.listView1.Items.Clear();
    Thread workthread = new Thread(new ThreadStart(this.DoSomething));
    workthread.Start();
}

private void DoSomething()
{
    for (int i = 0; i < 30; i++)
    {
        this.Invoke(new Action<int>(this.LoadPicture), i);
        Thread.Sleep(100);
    }
}

private void LoadPicture(int i)
{
    string text = string.Format("Item{0}", i);
    ListViewItem lvi = new ListViewItem(text, 0);
    this.listView1.Items.Add(lvi);
    Thread.Sleep(200);//模拟耗时UI任务，非循环，不可分解
}

备注：

1、Invoke和BeginInvoke
在多线程编程中，我们经常要在工作线程中去更新界面显示，而在多线程中直接调用界面控件的方法是错误的做法，正确的做法是将工作线程中涉及更新界面的代码封装为一个方法，通过Invoke或者BeginInvoke去调用，两者的区别就是一个导致工作线程等待，而另外一个则不会。

而所谓的“一面响应操作，一面添加节点”永远只能是相对的，使UI线程的负担不至于太大而以，因为界面的正确更新始终要通过UI线程去做，我们要做的事情是在工作线程中包揽大部分的运算，而将对纯粹的界面更新放到UI线程中去做，这样也就达到了减轻UI线程负担的目的了。

2、Application.DoEvent
在耗时的循环的UI更新的方法中，插入Application.DoEvent，会使界面获得响应，Application.DoEvent会调用消息处理程序。
private void button2_Click(object sender, EventArgs e)
{
    for (int i = 0; i < 30; i++)
    {
        string text = string.Format("Item{0}", i);
        ListViewItem lvi = new ListViewItem(text, 0);
        this.listView1.Items.Add(lvi);
        Thread.Sleep(200);
        for (int j = 0; j < 10; j++)
        {
            Thread.Sleep(10);
            Application.DoEvents();
        }
    }           
}

二、线程同步
什么是线程同步？ 多个线程同时运行时，可能会因为线程之间的逻辑关系而决定谁先执行，谁后执行， 这就是线程同步。
System.Threading命名空间提供了多个用于同步线程的类。这些类包括Mutex,Monitor,Interlocked,AutoResetEvent.  但是实际应用程序中，我们使用最多的可能不是这些类，而是C#提供的lock语句。
2.1 lock关键字
    2.1.1 将实例成员设为线程安全的
    2.1.2 lock关键字由编译器解析为Monitor类
    2.1.3 更快速的Interlocked类
2.2 WaitHandle
2.3 Mutex类
2.4 Semaphore类
2.5 Event类
    2.5.1 AutoResetEvent
    2.5.2 ManualResetEvent
2.6 ReaderWriterLockSlim类(.Net 3.5引入)

备注：
lock(object)
{

}
等价与
try
{
    Monitor.Enter(object);
}
finally
{
    Monitor.Exit(object)
}

三、异步委托
在C#中使用线程的方法很多，使用委托的BeginInvoke和EndInvoke方法就是其中之一。
BeginInvoke方法时会建立一个线程来异步执行newTask方法，并且这个线程是后台线程。这种线程一但所有的前台线程都退出后（其中主线程就是一个前台线程），不管后台线程是否执行完毕，都会结束线程，并退出程序。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace MyThread
{
    class Program
    {
        private static int newTask(int ms)
        {
            Console.WriteLine("任务开始");
            Thread.Sleep(ms);
            Random random = new Random();
            int n = random.Next(10000);
            Console.WriteLine("任务完成");
            return n;
        }
        private delegate int NewTaskDelegate(int ms);
        static void Main(string[] args)
        {
            NewTaskDelegate task = newTask;
            IAsyncResult asyncResult = task.BeginInvoke(2000, null, null);
            // EndInvoke方法将被阻塞2秒
            int result = task.EndInvoke(asyncResult);           
            Console.WriteLine(result);
        }
    }
}

使用IAsyncResult asyncResult属性来判断异步调用是否完成
虽然上面的方法可以很好地实现异步调用，但是当调用EndInvoke方法获得调用结果时，整个程序就象死了一样，这样做用户的感觉并不会太好，因此，我们可以使用asyncResult来判断异步调用是否完成，并显示一些提示信息。这样做可以增加用户体验。代码如下：
static void Main(string[] args)
{
    NewTaskDelegate task = newTask;
    IAsyncResult asyncResult = task.BeginInvoke(2000, null, null);
    while (!asyncResult.IsCompleted)
    {
        Console.Write("*");
        Thread.Sleep(100);
    }
    // 由于异步调用已经完成，因此， EndInvoke会立刻返回结果
    int result = task.EndInvoke(asyncResult);           
    Console.WriteLine(result);
}

使用WaitOne方法等待异步方法执行完成
static void Main(string[] args)
{
    NewTaskDelegate task = newTask;
    IAsyncResult asyncResult = task.BeginInvoke(2000, null, null);
    while (!asyncResult.AsyncWaitHandle.WaitOne(100, false))
    {
         Console.Write("*");              
    }
    int result = task.EndInvoke(asyncResult);
    Console.WriteLine(result);
}

使用回调方式返回结果
上面介绍的几种方法实际上只相当于一种方法。这些方法虽然可以成功返回结果，也可以给用户一些提示，但在这个过程中，整个程序就象死了一样（如果读者在GUI程序中使用这些方法就会非常明显），要想在调用的过程中，程序仍然可以正常做其它的工作，就必须使用异步调用的方式。下面我们使用GUI程序来编写一个例子，代码如下：
private delegate int MyMethod();
private int method()
{
    Thread.Sleep(10000);
    return 100;
}

private void MethodCompleted(IAsyncResult asyncResult)
{
    if (asyncResult == null) return;
    textBox1.Text = (asyncResult.AsyncState as
    MyMethod).EndInvoke(asyncResult).ToString();
}

private void button1_Click(object sender, EventArgs e)
{
    MyMethod my = method;
    IAsyncResult asyncResult = my.BeginInvoke(MethodCompleted, my);
}

四、线程池
每CLR一个线程池，这个线程池由CLR控制的所有AppDomain共享。如果一个进程中加载了多个CLR，那么每个CLR都有它自己的线程池。（就是说，AppDomain和线程池是一对一的关系）


五、线程的执行上下文

参考资料：
http://www.cnblogs.com/seabluescn/archive/2009/07/16/1524718.html
http://www.cnblogs.com/ChrisChen3121/archive/2013/04/15/3021723.html
http://www.cnblogs.com/axing/archive/2011/08/25/lock.html（Lock锁）
http://www.cnblogs.com/JeffreyZhao/archive/2008/03/01/async-query-with-linq-to-sql.html（异步线程）
http://www.cnblogs.com/JeffreyZhao/archive/2008/02/24/use-async-operation-properly.html（异步线程）
CLR via C#（第四版）