上接稳扎稳打Silverlight(26) - 2.0线程之Lock, Interlocked, EventWaitHandle, Monitor

<UserControl x:Class="Silverlight20.Thread.EventWaitHandle" 
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
        <StackPanel HorizontalAlignment="Left" Margin="5"> 

                <TextBlock x:Name="txtAutoResetEvent" /> 
                 
                <TextBlock x:Name="txtManualResetEvent" /> 

        </StackPanel> 
</UserControl>

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation; 
using System.Windows.Shapes; 
 
namespace Silverlight20.Thread 
{ 
         public partial  class EventWaitHandle : UserControl 
        { 
                 // AutoResetEvent(bool state) - 通知其他线程是否可入的类，自动 Reset() 
                 //         bool state - 是否为终止状态，即是否禁止其他线程入内 
                 private System.Threading.AutoResetEvent autoResetEvent =    
                         new System.Threading.AutoResetEvent( false); 
 
                 // ManualResetEvent(bool state) - 通知其他线程是否可入的类，手动 Reset() 
                 //         bool state - 是否为终止状态，即是否禁止其他线程入内 
                 private System.Threading.ManualResetEvent manualResetEvent =    
                         new System.Threading.ManualResetEvent( false); 
 
                 private  static  int i; 
 
                 public EventWaitHandle() 
                { 
                        InitializeComponent(); 
 
                         // 演示 AutoResetEvent 
                        AutoResetEventDemo(); 
 
                         // 演示 ManualResetEvent 
                        ManualResetEventDemo(); 
                } 
 
                 private  void AutoResetEventDemo() 
                { 
                        i = 0; 
 
                         for ( int x = 0; x < 100; x++) 
                        { 
                                 // 开 100 个线程去操作静态变量 i 
                                System.Threading.Thread thread = 
                                         new System.Threading.Thread( new System.Threading.ThreadStart(AutoResetEventDemoCallback)); 
                                thread.Start(); 
 
                                 // 阻塞当前线程，直到 AutoResetEvent 发出 Set() 信号 
                                autoResetEvent.WaitOne(); 
                        } 
 
                        System.Threading.Thread.Sleep(1000); 
                         // 1 秒后 100 个线程都应该执行完毕了，取得 i 的结果 
                        txtAutoResetEvent.Text = i.ToString(); 
                } 
 
                 private  void AutoResetEventDemoCallback() 
                { 
                         try 
                        { 
                                 int j = i + 1; 
 
                                 // 模拟多线程并发操作静态变量 i 的情况 
                                System.Threading.Thread.Sleep(5); 
 
                                i = j; 
                        } 
                         finally 
                        { 
                                 // 发出 Set() 信号，以释放 AutoResetEvent 所阻塞的线程 
                                autoResetEvent.Set(); 
                        } 
                } 
 
 
                 private  void ManualResetEventDemo() 
                { 
                        i = 0; 
 
                         for ( int x = 0; x < 100; x++) 
                        { 
                                 // Reset() - 将 ManualResetEvent 变为非终止状态，即由此线程控制 ManualResetEvent， 
                                 //         其他线程排队，直到 ManualResetEvent 发出 Set() 信号（AutoResetEvent 在 Set() 时会自动 Reset()） 
                                manualResetEvent.Reset(); 
 
                                 // 开 100 个线程去操作静态变量 i 
                                System.Threading.Thread thread = 
                                         new System.Threading.Thread( new System.Threading.ThreadStart(ManualResetEventDemoCallback)); 
                                thread.Start(); 
 
                                 // 阻塞当前线程，直到 ManualResetEvent 发出 Set() 信号 
                                manualResetEvent.WaitOne(); 
                        } 
 
                        System.Threading.Thread.Sleep(1000); 
                         // 1 秒后 100 个线程都应该执行完毕了，取得 i 的结果 
                        txtManualResetEvent.Text = i.ToString(); 
                } 
 
                 private  void ManualResetEventDemoCallback() 
                { 
                         try 
                        { 
                                 int j = i + 1; 
 
                                 // 模拟多线程并发操作静态变量 i 的情况 
                                System.Threading.Thread.Sleep(5); 
 
                                i = j; 
                        } 
                         finally 
                        { 
                                 // 发出 Set() 信号，以释放 ManualResetEvent 所阻塞的线程，同时 ManualResetEvent 变为终止状态） 
                                manualResetEvent.Set(); 
                        } 
                } 
        } 
}

<UserControl x:Class="Silverlight20.Thread.Monitor" 
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
        <StackPanel HorizontalAlignment="Left" Margin="5"> 

                <TextBlock x:Name="txtMsg" /> 

        </StackPanel> 
</UserControl>

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation; 
using System.Windows.Shapes; 
 
namespace Silverlight20.Thread 
{ 
         public partial  class Monitor : UserControl 
        { 
                 private  static  readonly  object objLock =  new  object(); 
                 private  static  int i; 
                 
                 public Monitor() 
                { 
                        InitializeComponent(); 
 
                        i = 0; 
 
                         for ( int x = 0; x < 100; x++) 
                        { 
                                 // 开 100 个线程去操作静态变量 i 
                                System.Threading.Thread thread =  new System.Threading.Thread( new System.Threading.ThreadStart(DoWork)); 
                                thread.Start(); 
                        } 
 
                        System.Threading.Thread.Sleep(1000); 
                         // 1 秒后 100 个线程都应该执行完毕了，取得 i 的结果 
                        txtMsg.Text = i.ToString(); 
                } 
 
                 private  void DoWork() 
                { 
                         try 
                        { 
                                 // Monitor - 提供同步访问对象的机制 
 
                                 // Enter() - 在指定对象上获取排他锁 
                                System.Threading.Monitor.Enter(objLock); 
 
                                 int j = i + 1; 
 
                                 // 模拟多线程并发操作静态变量 i 的情况 
                                System.Threading.Thread.Sleep(5); 
 
                                i = j; 
 
                                 // Exit() - 释放指定对象上的排他锁 
                                System.Threading.Monitor.Exit(objLock); 
                        } 
                         finally 
                        { 
                                 // code 
                        } 
                } 
        } 
}

<UserControl x:Class="Silverlight20.Thread.ThreadStaticAttribute" 
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
        <StackPanel HorizontalAlignment="Left" Margin="5"> 
         
                <TextBlock x:Name="txtMsg" /> 
                 
                <TextBlock x:Name="txtMsg2" /> 

        </StackPanel> 
</UserControl>

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation; 
using System.Windows.Shapes; 
 
namespace Silverlight20.Thread 
{ 
         public partial  class ThreadStaticAttribute : UserControl 
        { 
                 // ThreadStatic - 所指定的静态变量对每个线程都是唯一的 
                [System.ThreadStatic] 
                 private  static  int value; 
 
                 // 一般的静态变量，对每个线程都是共用的 
                 private  static  int value2; 
 
                 public ThreadStaticAttribute() 
                { 
                        InitializeComponent(); 
 
                        Demo(); 
                } 
 
                 void Demo() 
                { 
                        System.Threading.Thread thread =  new System.Threading.Thread(DoWork); 
                        thread.Name =  "线程1"; 
                        thread.Start(); 
 
                        System.Threading.Thread.Sleep(100); 
 
                        System.Threading.Thread thread2 =  new System.Threading.Thread(DoWork2); 
                        thread2.Name =  "线程2"; 
                        thread2.Start(); 
 
                } 
 
                 void DoWork() 
                { 
                         for ( int i = 0; i < 10; i++) 
                        { 
                                 // 线程1对静态变量的操作 
                                value++; 
                                value2++; 
                        } 
 
                         string s = value.ToString();  // value - 本线程独有的静态变量 
                         string s2 = value2.ToString();  // value2 - 所有线程共用的静态变量 
 
                         this.Dispatcher.BeginInvoke( delegate { txtMsg.Text = s +  " - " + s2; }); 
                         // this.Dispatcher.BeginInvoke(delegate { txtMsg.Text = value + " - " + value2; }); // 在UI线程上调用，所以value值为UI线程上的value值，即 0    
                } 
 
                 void DoWork2() 
                { 
                         for ( int i = 0; i < 10; i++) 
                        { 
                                 // 线程2对静态变量的操作 
                                value++; 
                                value2++; 
                        } 
 
                         string s = value.ToString();  // value - 本线程独有的静态变量 
                         string s2 = value2.ToString();  // value2 - 所有线程共用的静态变量 
 
                         this.Dispatcher.BeginInvoke( delegate { txtMsg2.Text = s +  " - " + s2; }); 
                         // this.Dispatcher.BeginInvoke(delegate { txtMsg2.Text = value + " - " + value2; }); // 在UI线程上调用，所以value值为UI线程上的value值，即 0    
                } 
        } 
}