多线程的应用小结

Posted 2020-07-21 weixiao520

一、使用多线程的几种方式

1. 不需要传递参数,也不需要返回参数

   ThreadStart是一个委托，这个委托的定义为void ThreadStart()，没有参数与返回值。

   class Program

   {

   static void Main(string[] args)

   {

   for (int i = 0; i < 30; i++)

   {

   ThreadStart threadStart = new ThreadStart(Calculate);

   Thread thread = new Thread(threadStart);

   thread.Start();

   }

   Thread.Sleep(2000);

   Console.Read();

   }

   public static void Calculate()

   {

   DateTime time = DateTime.Now;//得到当前时间

   Random ra = new Random();//随机数对象

   Thread.Sleep(ra.Next(10,100));//随机休眠一段时间

   Console.WriteLine(time.Minute + ":" + time.Millisecond);

   }

   }

2. 需要传递单个参数

   ParameterThreadStart委托定义为void ParameterizedThreadStart(object state)，有一个参数但是没有返回值。

   class Program

   {

   static void Main(string[] args)

   {

   for (int i = 0; i < 30; i++)

   {

   ParameterizedThreadStart tStart = new ParameterizedThreadStart(Calculate);

   Thread thread = new Thread(tStart);

   thread.Start(i*10+10);//传递参数

   }

   Thread.Sleep(2000);

   Console.Read();

   }

   public static void Calculate(object arg)

   {

   Random ra = new Random();//随机数对象

   Thread.Sleep(ra.Next(10, 100));//随机休眠一段时间

   Console.WriteLine(arg);

   }

   }

3. 使用专门的线程类(常用)

   使用线程类可以有多个参数与多个返回值，十分灵活！

   class Program

   {

   static void Main(string[] args)

   {

   MyThread mt = new MyThread(100);

   ThreadStart threadStart = new ThreadStart(mt.Calculate);

   Thread thread = new Thread(threadStart);

   thread.Start();

   //等待线程结束

   while (thread.ThreadState != ThreadState.Stopped)

   {

   Thread.Sleep(10);

   }

   Console.WriteLine(mt.Result);//打印返回值

   Console.Read();

   }

   }

   public class MyThread//线程类

   {

   public int Parame { set; get; }//参数

   public int Result { set; get; }//返回值

   //构造函数

   public MyThread(int parame)

   {

   this.Parame = parame;

   }

   //线程执行方法

   public void Calculate()

   {

   Random ra = new Random();//随机数对象

   Thread.Sleep(ra.Next(10, 100));//随机休眠一段时间

   Console.WriteLine(this.Parame);

   this.Result = this.Parame * ra.Next(10, 100);

   }

   }

4. 使用匿名方法(常用)

   使用匿名方法启动线程可以有多个参数和返回值，而且使用非常方便！

   class Program

   {

   static void Main(string[] args)

   {

   int Parame = 100;//当做参数

   int Result = 0;//当做返回值

   //匿名方法

   ThreadStart threadStart = new ThreadStart(delegate()

   {

   Random ra = new Random();//随机数对象

   Thread.Sleep(ra.Next(10, 100));//随机休眠一段时间

   Console.WriteLine(Parame);//输出参数

   Result = Parame * ra.Next(10, 100);//计算返回值

   });

   Thread thread = new Thread(threadStart);

   thread.Start();//多线程启动匿名方法

   //等待线程结束

   while (thread.ThreadState != ThreadState.Stopped)

   {

   Thread.Sleep(10);

   }

   Console.WriteLine(Result);//打印返回值

   Console.Read();

   }

   }

使用委托开启多线程(多线程深入)

1. 用委托(Delegate)的BeginInvoke和EndInvoke方法操作线程

   BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。我们可以通过四种方法从EndInvoke方法来获得返回值。

   class Program

   {

   private delegate int NewTaskDelegate(int ms);

   private static int newTask(int ms)

   {

   Console.WriteLine("任务开始");

   Thread.Sleep(ms);

   Random random = new Random();

   int n = random.Next(10000);

   Console.WriteLine("任务完成");

   return n;

   }

   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);

   Console.Read();

   }

   }

2. 使用IAsyncResult.IsCompleted属性来判断异步调用是否完成

   class Program

   {

   private delegate int NewTaskDelegate(int ms);

   private static int newTask(int ms)

   {

   Console.WriteLine("任务开始");

   Thread.Sleep(ms);

   Random random = new Random();

   int n = random.Next(10000);

   Console.WriteLine("任务完成");

   return n;

   }

   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);

   Console.Read();

   }

   }

3. 使用WaitOne方法等待异步方法执行完成

   WaitOne的第一个参数表示要等待的毫秒数，在指定时间之内，WaitOne方法将一直等待，直到异步调用完成，并发出通知，WaitOne方法才返回true。当等待指定时间之后，异步调用仍未完成，WaitOne方法返回false，如果指定时间为0，表示不等待，如果为-1，表示永远等待，直到异步调用完成。

   class Program

   {

   private delegate int NewTaskDelegate(int ms);

   private static int newTask(int ms)

   {

   Console.WriteLine("任务开始");

   Thread.Sleep(ms);

   Random random = new Random();

   int n = random.Next(10000);

   Console.WriteLine("任务完成");

   return n;

   }

   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);

   Console.Read();

   }

   }

4. 使用回调方式返回结果

   要注意的是"my.BeginInvoke(3,300, MethodCompleted, my)"，BeginInvoke方法的参数传递方式：

   前面一部分(3,300)是其委托本身的参数。

   倒数第二个参数(MethodCompleted)是回调方法委托类型，他是回调方法的委托，此委托没有返回值，有一个IAsyncResult类型的参数，当method方法执行完后，系统会自动调用MethodCompleted方法。

   最后一个参数(my)需要向MethodCompleted方法中传递一些值，一般可以传递被调用方法的委托，这个值可以使用IAsyncResult.AsyncState属性获得。

   class Program

   {

   private delegate int MyMethod(int second, int millisecond);

   //线程执行方法

   private static int method(int second, int millisecond)

   {

   Console.WriteLine("线程休眠" + (second * 1000 + millisecond) + "毫秒");

   Thread.Sleep(second * 1000 + millisecond);

   Random random = new Random();

   return random.Next(10000);

   }

   //回调方法

   private static void MethodCompleted(IAsyncResult asyncResult)

   {

   if (asyncResult == null || asyncResult.AsyncState == null)

   {

   Console.WriteLine("回调失败！！！");

   return;

   }

   int result = (asyncResult.AsyncState as MyMethod).EndInvoke(asyncResult);

   Console.WriteLine("任务完成，结果：" + result);

   }

   static void Main(string[] args)

   {

   MyMethod my = method;

   IAsyncResult asyncResult = my.BeginInvoke(3,300, MethodCompleted, my);

   Console.WriteLine("任务开始");

   Console.Read();

   }

   }

 

其他组件的BeginXXX和EndXXX方法

在其他的.net组件中也有类似BeginInvoke和EndInvoke的方法，如System.Net.HttpWebRequest类的BeginGetResponse和EndGetResponse方法。其使用方法类似于委托类型的BeginInvoke和EndInvoke方法，例如：

class Program

{

//回调函数

private static void requestCompleted(IAsyncResult asyncResult)

{

if (asyncResult == null || asyncResult.AsyncState==null)

{

Console.WriteLine("回调失败");

return;

}

HttpWebRequest hwr = asyncResult.AsyncState as HttpWebRequest;

HttpWebResponse response = (HttpWebResponse)hwr.EndGetResponse(asyncResult);

StreamReader sr = new StreamReader(response.GetResponseStream());

string str = sr.ReadToEnd();

Console.WriteLine("返回流长度："+str.Length);

}

static void Main(string[] args)

{

HttpWebRequest request =

(HttpWebRequest)WebRequest.Create("http://www.baidu.com");

//异步请求

IAsyncResult asyncResult = request.BeginGetResponse(requestCompleted, request);

Console.WriteLine("任务开始");

Console.Read();

}

}

二、线程的状态控制

 

1. 前台线程与后台线程

   Thread.IsBackground属性为true则是后台线程，为false则是前台线程。后台线程与前台线程区别如下：

   a.当在主线程中创建了一个线程，那么该线程的IsBackground默认是设置为false的。

   b.当主线程退出的时候，IsBackground=false的线程还会继续执行下去，直到线程执行结束。只有IsBackground=true的线程才会随着主线程的退出而退出。

   c.当初始化一个线程，把Thread.IsBackground=true的时候，指示该线程为后台线程。后台线程将会随着主线程的退出而退出。

   d.原理：只要所有前台线程都终止后，CLR就会对每一个活在的后台线程调用Abort()来彻底终止应用程序

2. 由线程类(Thread)启动动的线程状态控制

   使用System.Threading.ThreadState与System.Diagnostics.ThreadState枚举判断线程状态，与Thread.ThreadState 属性配合使用。

   System.Threading.ThreadState枚举状态：

   

   System.Diagnostics.ThreadState枚举状态：

   

   注意：您的代码在任何情况下都不应使用线程状态来同步线程的活动。

   

 

由委托启动的线程的状态控制

委托的EndInvoke方法阻止当前线程运行，直到委托异步执行完成。

IAsyncResult.IsCompleted属性表示委托异步执行是否完成。

委托的WaitOne方法等待异步方法执行完成。

三、多线程访问GUI界面的处理

 

1. 多线程在GUI编程时出现的问题

   在GUI编程时，如果你从非创建这个控件的线程中访问这个控件或者操作这个控件的话就会抛出这个异常。这是微软为了保证线程安全以及提高代码的效率所做的改进，但是也给大家带来很多不便。

2. 通过设置处理

   设置System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;在你的程序初始化的时候设置了这个属性，而且在你的控件中使用的都是微软Framework类库中的控件的话，系统就不会再抛出你上面所说的这个错误了。

3. 通过委托处理(建议使用)

   //按钮事件

   private void button1_Click(object sender, EventArgs e)

   {

   Thread thread = new Thread(Flush);

   thread.IsBackground = true;//设置成后台线程

   thread.Start();

   }

   //线程执行的方法

   private void Flush()

   {

   //定义委托

   Action action = delegate()

   {

   this.textBox1.AppendText(DateTime.Now.ToString() + "\\r\\n");

   };

   while (true)

   {

   //判断能否到当前线程操作该组件

   if (this.textBox1.InvokeRequired)

   {

   //不在当前线程上操作

   this.textBox1.Invoke(action);//调用委托

   }

   else

   {

   //在当前线程上操作

   this.textBox1.AppendText(DateTime.Now.ToString() + "\\r\\n");

   }

   Thread.Sleep(1000);

   }

   注意：使用该方式不会有无响应的情况发生，强烈建议使用该方式。此方式不会发生界面无响应的关键点：调用this.textBox1.Invoke(action)就是在拥有this.textBox1对象的线程(不一定是当前线程，多数是主线程)上调用action委托，若action委托指向的方法执行时间过长就会使得界面无响应！而该方式中action委托指向的方法执行时间极为短。

4. 调用控件的Invoke和BeginInvoke方法的区别

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

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

5. Application.DoEvents()调用消息处理程序

   在耗时的循环的UI更新的方法中，插入Application.DoEvents()，会使界面获得响应，Application.DoEvents()会调用消息处理程序。

 

使用BackgroundWorker组件

主要的事件及参数：

1.DoWork—当执行BackgroundWorker.RunWorkerAsync方法时会触发该事件，并且传递以上是关于多线程的应用小结的主要内容，如果未能解决你的问题，请参考以下文章

多线程的几种实现方式

JAVA多线程实现的几种方式

java多线程---创建线程的几种方式

多线程下处理变量共享的几种方式

最近在研究多线程，浅谈JAVA中多线程的几种实现方式

Python 实现多线程的几种方式