多线程学习

一直搞web开发,每天接触最多的就是asp.net+css+js,看了看petshop,原来多线程在Web项目中也有很大作用.加之以前一直对多线程不甚了解,这次就这个机会来一次自我补习吧.

 

启用一个新线程有四种写法:

第一种:使用Thread与ThreadStart/ParameterizedThreadStart类

代码

  static   void  Main( string [] args)  
         {  
             Thread th  =   new  Thread( new  ThreadStart(Print));  
             Thread thp  =   new  Thread( new  ParameterizedThreadStart(Print));  
             th.Start();  
             thp.Start( " ljzforever " );  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 Console.WriteLine(i.ToString()  +   " ------------------- " );  
             }  
             Console.Read();  
         }  
   
          static   void  Print()  
         {  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 Console.WriteLine(i.ToString());  
             }  
         }  
   
          static   void  Print( object  obj)  
         {  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 Console.WriteLine(i.ToString()  +  (obj == null   ?   ""  : obj.ToString()));  
             }  
         }

 

ThreadStart类与ParameterizedThreadStart类区别就是前者不能传参,而后者可以.

 在2.0支持匿名委托的基础上,ThreadStart类与ParameterizedThreadStart类可以不写:

 

Thread th  =   new  Thread(Print);  
Thread thp  =   new  Thread(Print);

 

这种开启线的方式有个限制,就是其包装的方法的方法签名必须与委托一致:无返回值,无参或者只有一个object型参数.

 

第二种:使用线程池:

 

代码

  class  Program  
     {  
          static   void  Main( string [] args)  
         {  
             ThreadPool.QueueUserWorkItem(Print,  " +++ " );  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 Console.WriteLine();  
             }  
             Console.Read();  
         }  
   
          static   void  Print( object  obj)  
         {  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 Console.WriteLine(i.ToString()  +  (obj  ==   null   ?   ""  : obj.ToString()));  
             }  
         }  
     }

 

如无特殊要求,这种方法是可以使用的,它让.net自行维护线程资源的开启与释放.

以上两种方法都有很大限制,就是不能让任意方法开启线程,当然,这是有方法解决的,就是把你需要的方法再封装成与委托相对应的签名,这无疑是把问题搞复杂了,所以就有了以下两种方法:

 

第三种:使用Asynchronous Results模式

 

 

代码

  delegate   int  GetNumberHandler( string  pre,  string  last);  
   
          static   void  Main( string [] args)  
         {  
             GetNumberHandler getNumber  =  GetNumber;  
             IAsyncResult asyn  =  getNumber.BeginInvoke( "" ,  " %%% " , Complete,  " ljzforever " );  
   
              for  ( int  j  =   0 ; j  <   100 ; j ++ )  
             {  
                 Console.WriteLine(j.ToString());  
             }  
             Console.ReadKey();  
         }  
   
          static   int  GetNumber( string  pre,  string  last)  
         {  
              int  j  =   0 ;  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 Console.WriteLine(pre  +  i.ToString()  +  last);  
                 j  +=  i;  
             }  
              return  j;  
         }  
   
          static   void  Complete(IAsyncResult result)  
         {  
             Console.WriteLine(result.AsyncState.ToString());  
             GetNumberHandler getNumber  =  (result  as  AsyncResult).AsyncDelegate  as  GetNumberHandler;  
             Console.WriteLine(getNumber.EndInvoke(result).ToString());  
         } 

 

 说白了,就是给你需要开启线程的方法声明一个委托,然后用委托封装方法,最后执行委托的BeginInvoke方法.就会自己开启一个线程了,然后用 EndInvoke方法来获取执行结果.其中其第一,二个参数是与你声明的委托有关的,委托有几个参数,这里就需要几个参数,其中in与ref参数需要写 在BeginInvoke内,ref与out参数需要写在EndInvoke内,如:

 

delegate   bool  Handler( string  str,  ref   object  obj,  out   object  obj2)  
BeginInvoke( string  str,  ref   object  obj)  
EndInvoke( ref   object  obj,  out   object  obj2)

 后面两个是固定参数.前一个是当异步线程结束时会调用的方法,后一个是传给结束调用方法的参数.从result.AsyncState获取.上面的Demo内有交待,就不多说了.

这种方法最灵活,但是如果你想对异步的线程有更多的控制时,就可以使用第四种方法:

 

第四种:Background Worker模式

 

代码

  static  BackgroundWorker bw  =   new  BackgroundWorker();  
   
          static   void  Main( string [] args)  
         {  
             bw.DoWork  +=   new  DoWorkEventHandler(bw_DoWork);  
             bw.WorkerReportsProgress  =   true ;  
             bw.ProgressChanged  +=   new  ProgressChangedEventHandler(bw_ProgressChanged);  
             bw.RunWorkerCompleted  +=   new  RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);  
             bw.WorkerSupportsCancellation  =   true ;  
   
             bw.RunWorkerAsync();  
             Console.Read();  
         }  
   
          static   void  bw_RunWorkerCompleted( object  sender, RunWorkerCompletedEventArgs e)  
         {  
              if  (e.Cancelled  ==   true )  
             {  
                 Console.WriteLine( " NONComplete---------------- " );  
             }  
              else   
             {  
                 Console.WriteLine( " Complete---------------- "   +  e.Result.ToString());  
             }  
              
         }  
   
          static   void  bw_ProgressChanged( object  sender, ProgressChangedEventArgs e)  
         {  
             Console.WriteLine(e.ProgressPercentage  +   " % "   +   " ---------- "   +  e.UserState.ToString());  
              if  (e.ProgressPercentage  ==   10 )  
             {  
                 bw.CancelAsync();                  
             }  
         }  
   
          static   void  bw_DoWork( object  sender, DoWorkEventArgs e)  
         {  
              int  result  =   0 ;  
              for  ( int  i  =   0 ; i  <   100 ; i ++ )  
             {  
                 result  +=  i;  
                 Console.WriteLine(i.ToString());  
                 bw.ReportProgress(i, i);  
                  if  (bw.CancellationPending)  
                 {  
                     e.Cancel  =   true ;  
                      break ;  
                 }  
             }  
             e.Result  =  result;  
         } 

将要异步执行的方法加入DoWork委托,将要进行进度控制的方法加入ProgressChanged 委托并将WorkerReportsProgress 设为true,通过ReportProgress()方法来触发进程控制.将线程完成时需要执行的方法加入RunWorkerCompleted委托,如 果中途想中段进程,需要将WorkerSupportsCancellation 属性设为True,并通过调用CancelAsync()方法来中断进程.通过CancellationPending属性来判断进程是否被中断.最后, 通过RunWorkerAsync()方法来启动线程.

这种方法给予我们强大的线程控制能力,不过它的弱点也很明显,就是被它封装的方法必须满足它的方法签名.

 

从上面看来多线程似乎很简单,其实不然,多线程难点之一就是线程同步,就是对同一对象同一时间只能有一个线程进行访问.net中是能过Monitor与lock关键字来进行同步的:

 

代码

  const   int  nMax  =   1000000 ;  
          static   int  nCount  =   0 ;  
          static   object  obj  =   new   object ();  
   
          static   void  Main( string [] args)  
         {  
              // ThreadPool.QueueUserWorkItem(Change);  
             Thread th  =   new  Thread(Change);  
             th.Start();  
              for  ( int  i  =   0 ; i  <  nMax; i ++ )  
             {  
                 Monitor.Enter(obj);  
                 nCount ++ ;  
                 Monitor.Exit(obj);  
             }  
             th.Join();  
             Console.WriteLine(nCount.ToString());  
             Console.ReadKey();  
         }  
   
          static   void  Change()  
         {  
              for  ( int  i  =   0 ; i  <  nMax; i ++ )  
             {  
                 Monitor.Enter(obj);  
                 nCount -- ;  
                 Monitor.Exit(obj);  
             }  
         }

 

 

 

比如++与--操作,虽然是一个操作符,但实际.net运算中是分为多个步骤进行的,如果一个步骤没有进行完就切换成另一个线程操作,其结果就只能 是得不到想要的结果,办法就是加入上面所示的代码来强制保证执行的完整性.不过因为使用了同步,所以性能会有一定程度的损失.上面的例子请用百万以上的数 字进行测试.

 

下面来谈谈winform下的多线程.上面的例子全是在控制台下执行的,而winform下的多线程则大同小异:

 

 

 

 

 

代码

  public  Form1()  
         {  
             InitializeComponent();  
         }  
   
          private   void  btnChange_Click( object  sender, EventArgs e)  
         {  
             Thread th  =   new  Thread(Change);  
             th.Start();  
         }  
   
          public   void  Change()  
         {  
              if  (lblTitle.InvokeRequired)  
             {  
                 MethodInvoker invoke  =  Change;  
                 Invoke(invoke);  
             }  
              else   
             {  
                 lblTitle.Text  =   " 改变啦! " ;  
             }  
         }  
   
          private   void  btnChange2_Click( object  sender, EventArgs e)  
         {  
             Thread th  =   new  Thread(Change2);  
             th.Start(txtContent.Text.Trim());  
         }  
   
          delegate   void  Change2Handler( object  obj);  
          public   void  Change2( object  obj)  
         {  
              if  (lblTitle.InvokeRequired)  
             {  
                 Change2Handler invoke  =  Change2;  
                 Invoke(invoke, obj);  
             }  
              else   
             {  
                 lblTitle.Text  =  obj.ToString();  
             }  
         }

 

 在winform下,控件只能被它创建的控制调用.如果想被另一个线程访问,则需要进行判断:

 

InvokeRequired

 

 

InvokeRequired需要比较调用线程ID和创建线程ID,如果它们不相同则返回true,这时,就需要用一个委托对此方法时行封装,如上 面的系统委托MethodInvoker 与 自己编写的委托 Change2Handler.然后调用Invoke方法,通知创建线程来执行这个委托.

当然,还有另外一个方法:

 

 

Control.CheckForIllegalCrossThreadCalls  =   false ;  

如果设成false.net就不会对进程间调用进行检查,这样就可以跨线程对控件进行操作.

 

 

 

Demo下载:

http://ljzforever.qupan.com/?folder=951925