c# 线程间同步

理解SynchronizationContext
--------------------------------------------------------------------------------
　 　SynchronizationContext 类是一个基类，可提供不带同步的自由线程上下文。 此类实现的同步模型的目的是使公共语言运行库内部的异步/同步操作能够针对不同的异步模型采取正确的行 为。此模型还简化了托管应用程序为在不同的同步环境下正常工作而必须遵循 的一些要求。同步模型的提供程序可以扩展此类并为这些方法提供自己的实现。(来自MSDN)

　　简而言之就是允许一个线程和另外一个线程 进行通讯，SynchronizationContext在通讯中充当传输者的角色。另外这里有个地方需要清楚的，不是每个线程都附加 SynchronizationContext这个对象，只有UI线程是一直拥有的。

　　这里你可 能有个问题：对于UI线程来说，是如何将SynchronizationContext这个对象附加到线程上的呢？！OK，我们先从下面的代码开始，

1. [STAThread]
   
2. static void Main()
   
3. {
   
4.     Application.EnableVisualStyles();
   
5.     Application.SetCompatibleTextRenderingDefault(false);
   
6. 
   
7.     // let's check the context here
   
8.     var context = SynchronizationContext.Current;
   
9.     if (context == null)
   
10.         MessageBox.Show("No context for this thread");
    
11.     else
    
12.         MessageBox.Show("We got a context");
    
13. 
    
14.     // create a form
    
15.     Form1 form = new Form1();
    
16. 
    
17.     // let's check it again after creating a form
    
18.     context = SynchronizationContext.Current;
    
19. 
    
20.     if (context == null)
    
21.         MessageBox.Show("No context for this thread");
    
22.     else
    
23.         MessageBox.Show("We got a context");
    
24. 
    
25.     if (context == null)
    
26.         MessageBox.Show("No context for this thread");
    
27. 
    
28.     Application.Run(new Form1());
    
29. }
    

复制代码

运行结 果：
1、No context for this thread
2、We got a context
   
    从运行结果来看，在Form1 form = new Form1()之前，SynchronizationContext对象是为空，而当实例化Form1窗体 后，SynchronizationContext对象就被附加到这个线程上了。所以可以得出答案了：当Control对象被创建的同 时，SynchronizationContext对象也会被创建并附加到线程上。

    好的，我们既然已经基本了解了SynchronizationContext，接下来的事情就是使用它了！

如何使用 SynchronizationContext
--------------------------------------------------------------------------------
　 　应用程序有两个线程：线程A和线程B，不过线程B比较特殊，它属于UI线程，当这两个线程同时运行的时候，线程A有个需求："修改UI对象的属性"，这 时候如果你是线程A，你会如何去完成需求呢？！

第一种方式：   

    在线程A上面直接去操作UI对象，这是线程B说："线程A，你真xx，你不知道我的特殊嘛！"，然后直接抛给线程A一个异常信息，线程A得到异常后，一脸 的无辜和无奈.....!

第二种方式：

　　InvokeRequired？！是的，当然没问题。(解释 下，InvokeRequired属性是每个Control对象都具有的属性，它会返回true和false，当是true的时候，表示可以去修改UI对 象，反之则不允许。通过InvokeRequired的实现方式如下：

1. using System;
   
2. using System.Drawing;
   
3. using System.Windows.Forms;
   
4. using System.Threading;
   
5. 
   
6.   public class MyFormControl : Form
   
7.   {
   
8.       public delegate void AddListItem(String myString);
   
9.       public AddListItem myDelegate;
   
10.       private Button myButton;
    
11.       private Thread myThread;
    
12.       private ListBox myListBox;
    
13.       public MyFormControl()
    
14.       {
    
15.         myButton = new Button();
    
16.         myListBox = new ListBox();
    
17.         myButton.Location = new Point(72, 160);
    
18.         myButton.Size = new Size(152, 32);
    
19.         myButton.TabIndex = 1;
    
20.         myButton.Text = "Add items in list box";
    
21.         myButton.Click += new EventHandler(Button_Click);
    
22.         myListBox.Location = new Point(48, 32);
    
23.         myListBox.Name = "myListBox";
    
24.         myListBox.Size = new Size(200, 95);
    
25.         myListBox.TabIndex = 2;
    
26.         ClientSize = new Size(292, 273);
    
27.         Controls.AddRange(new Control[] {myListBox,myButton});
    
28.         Text = " 'Control_Invoke' example ";
    
29.         myDelegate = new AddListItem(AddListItemMethod);
    
30.       }
    
31.       static void Main()
    
32.       {
    
33.         MyFormControl myForm = new MyFormControl();
    
34.         myForm.ShowDialog();
    
35.       }
    
36.       public void AddListItemMethod(String myString)
    
37.       {
    
38.             myListBox.Items.Add(myString);
    
39.       }
    
40.       private void Button_Click(object sender, EventArgs e)
    
41.       {
    
42.         myThread = new Thread(new ThreadStart(ThreadFunction));
    
43.         myThread.Start();
    
44.       }
    
45.       private void ThreadFunction()
    
46.       {
    
47.         MyThreadClass myThreadClassObject  = new MyThreadClass(this);
    
48.         myThreadClassObject.Run();
    
49.       }
    
50.   }
    
51.   public class MyThreadClass
    
52.   {
    
53.       MyFormControl myFormControl1;
    
54.       public MyThreadClass(MyFormControl myForm)
    
55.       {
    
56.         myFormControl1 = myForm;
    
57.       }
    
58.       String myString;
    
59. 
    
60.       public void Run()
    
61.       {
    
62.         for (int i = 1; i <= 5; i++)
    
63.         {
    
64.             myString = "Step number " + i.ToString() + " executed";
    
65.             Thread.Sleep(400);
    
66.             // Execute the specified delegate on the thread that owns
    
67.             // 'myFormControl1' control's underlying window handle with
    
68.             // the specified list of arguments.
    
69.             myFormControl1.Invoke(myFormControl1.myDelegate,
    
70.                                   new Object[] {myString});
    
71.         }
    
72.       }
    
73.   }
    

复制代码

不过这里 存在一个有争论的地方：这种方式必须通过调用Control的Invoke方法来实现，这就是说调用的地方必须有一个Control的引用存在。

　 　看下MyThreadClass类，这个类中就存在MyFormControl的引用对象。其实如果这个类放在这里是没有任务不妥之处的，但是如果把 MyThreadClass类放在业务层，这时候问题就出现了，从设计角度来说，业务层是不允许和UI有任何关系，所以MyFormControl的引用 对象绝对不能存在于MyThreadClass类，但是不让它存在，更新UI控件的需求就满足不了，这种情况下，我们如何做到一种 最佳方案呢！？

第三种方式：

　　本文的主角：SynchronizationContext登场了。解释 之前，先让下面的代码做下铺垫，

1. public partial class Form1 : Form
   
2. {
   
3.     public Form1()
   
4.     {
   
5.         InitializeComponent();
   
6.     }
   
7. 
   
8.     private void mToolStripButtonThreads_Click(object sender, EventArgs e)
   
9.     {
   
10.         // let's see the thread id
    
11.         int id = Thread.CurrentThread.ManagedThreadId;
    
12.         Trace.WriteLine("mToolStripButtonThreads_Click thread: " + id);
    
13. 
    
14.         // grab the sync context associated to this
    
15.         // thread (the UI thread), and save it in uiContext
    
16.         // note that this context is set by the UI thread
    
17.         // during Form creation (outside of your control)
    
18.         // also note, that not every thread has a sync context attached to it.
    
19.         SynchronizationContext uiContext = SynchronizationContext.Current;
    
20. 
    
21.         // create a thread and associate it to the run method
    
22.         Thread thread = new Thread(Run);
    
23. 
    
24.         // start the thread, and pass it the UI context,
    
25.         // so this thread will be able to update the UI
    
26.         // from within the thread
    
27.         thread.Start(uiContext);
    
28.     }
    
29. 
    
30.     private void Run(object state)
    
31.     {
    
32.         // lets see the thread id
    
33.         int id = Thread.CurrentThread.ManagedThreadId;
    
34.         Trace.WriteLine("Run thread: " + id);
    
35. 
    
36.         // grab the context from the state
    
37.         SynchronizationContext uiContext = state as SynchronizationContext;
    
38. 
    
39.         for (int i = 0; i < 1000; i++)
    
40.         {
    
41.             // normally you would do some code here
    
42.             // to grab items from the database. or some long
    
43.             // computation
    
44.             Thread.Sleep(10);
    
45. 
    
46.             // use the ui context to execute the UpdateUI method,
    
47.             // this insure that the UpdateUI method will run on the UI thread.
    
48. 
    
49.             uiContext.Post(UpdateUI, "line " + i.ToString());
    
50.         }
    
51.     }
    
52. 
    
53.     ///
    
    
54.     /// This method is executed on the main UI thread.
    
55.     ///
    
56.     private void UpdateUI(object state)
    
57.     {
    
58.         int id = Thread.CurrentThread.ManagedThreadId;
    
59.         Trace.WriteLine("UpdateUI thread:" + id);
    
60.         string text = state as string;
    
61.         mListBox.Items.Add(text);
    
62.     }
    
63. }
    

复制代码

运行结 果：

mToolStripButtonThreads_Click thread: 10
Run thread: 3
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
(x1000 times)

    程序首先在Form1窗体的mToolStripButtonThreads_Click事件中，获取当前的 SynchronizationContext对象，然后启动另外一个线程，并且将SynchronizationContext对象传递给启动的线程， 启动的线程通过SynchronizationContext对象的Post方法来调用一个委托方法UpdateUI，因为UpdateUI是执行在主 UI线程上的，所以可以通过它来修改UI上对象的信息。

    怎么样！不错吧，现在我们可以把Control引用给抛弃了，哈哈！

    如果你去查下MSDN，会发现SynchronizationContext还有一个Send方法，Send和Post有什么区别？

Send VS Post,以及异常处理
--------------------------------------------------------------------------------
首 先看下异常处理的情况

1. private void Run(object state)
   
2. {
   
3.     // let's see the thread id
   
4.     int id = Thread.CurrentThread.ManagedThreadId;
   
5.     Trace.WriteLine("Run thread: " + id);
   
6. 
   
7.     // grab the context from the state
   
8.     SynchronizationContext uiContext = state as SynchronizationContext;
   
9. 
   
10.     for (int i = 0; i < 1000; i++)
    
11.     {
    
12.         Trace.WriteLine("Loop " + i.ToString());
    
13.         // normally you would do some code here
    
14.         // to grab items from the database. or some long
    
15.         // computation
    
16.         Thread.Sleep(10);
    
17. 
    
18.         // use the ui context to execute the UpdateUI method, this insure that the
    
19.         // UpdateUI method will run on the UI thread.
    
20. 
    
21.         try
    
22.         {
    
23.             uiContext.Send(UpdateUI, "line " + i.ToString());
    
24.         }
    
25.         catch (Exception e)
    
26.         {
    
27.             Trace.WriteLine(e.Message);
    
28.         }
    
29.     }
    
30. }
    
31. 
    
32. ///
    
    
33. /// This method is executed on the main UI thread.
    
34. ///
    
35. private void UpdateUI(object state)
    
36. {
    
37.     throw new Exception("Boom");
    
38. }
    

复制代码

当你运行 的时候， 你可能希望在UI线程上面去抛出，但是结果往往出忽你的意料，异常信息都在Run方法的线程上被捕获了。这时候你可能想问：WHY？！

解 释之前，我们先看下，Send VS Post的结果:
Send 方法启动一个同步请求以发送消息
Post 方法启动一个异步请求以发送消息。