欢迎光临
我的个人博客网站

C#中异步多线程的常见用法

  此篇文章是我一个小白对异步多线程的理解和总结,请高手多多批评指教。废话不说了,先来看几个基本概念(纯属个人见解,可能不准确):

进程:程序运行时,占用的全部运行资源的总和。

线程:线程是隶属于操作系统管理的,也可以有自己的计算资源,是程序执行流的最小单位。任何的操作都是由线程来完成的。

多线程:多核cpu协同工作,多个执行流同时运行,是用资源换时间。(单核cpu,不存在所谓的多线程)。

Thread

  Thread的对象是非线程池中的线程,有自己的生命周期(有创建和销毁的过程),所以不可以被重复利用(一个操作中,不会出现二个相同Id的线程)。

Thread的常见用法:

private void button5_Click(object sender, EventArgs e) {     
Console.WriteLine($
"===============Method start time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},Thread ID is {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}==================="); //开启一个线程,构造方法可重载两种委托,一个是无参无返回值,一个是带参无返回值 Thread thread = new Thread(a => DoSomeThing("Thread")); //当前线程状态 Console.WriteLine($"thread's state is {thread.ThreadState},thread's priority is {thread.Priority} ,thread is alived :{thread.IsAlive},thread is background:{thread.IsBackground},thread is pool threads: {thread.IsThreadPoolThread}"); //告知操作系统,当前线程可以被执行了。 thread.Start(); //阻塞当前执行线程,等待此thread线程实例执行完成。 thread.Join(); //最大等待的时间是5秒(不管是否执行完成,不再等待) thread.Join(5000); Console.WriteLine($"===============Method end time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},,Thread ID is {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}==================="); }
private void DoSomeThing(string name) { Console.WriteLine($"do some thing start time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},Thread ID is {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}"); long result = 0; for (long i = 0; i < 10000 * 10000; i++) { result += i; } Console.WriteLine($"do some thing end time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},Thread ID is {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}"); }

注意 :thread 默认是前台线程,启动后一定要完成任务的,即使程序关掉(进程退出)也要执行完。可以把thread 指定为后台线程,随着进程的退出而终止。

//false,默认是前台线程,启动后一定要完成任务的,即使程序关掉(进程退出)也要执行完。 Console.WriteLine(thread.IsBackground);  thread.IsBackground = true;//指定为后台线程。(随着进程的退出而退出)

Thread的回调用法:

Thread没有像Framework中的delegate的回调用法,如果需要回调得自动动手改造:

private void CallBack(Action action, Action calback) {     Thread thread = new Thread(() => { action(); calback(); });     thread.Start(); } //无参无返回值 CallBack(() => Console.WriteLine("好吗?"), () => Console.WriteLine("好的!"));

private Func<T> CallBackReturn<T>(Func<T> func) {     T t = default(T);     Thread thread = new Thread(() =>     {         t = func();     });     thread.Start();     return () =>     {         thread.Join();         return t;     }; } //带返回值得用法 Func<int> func = CallBackReturn<int>(() => DateTime.Now.Second); Console.WriteLine("线程未阻塞"); int result = func.Invoke(); Console.WriteLine("result:" + result);

ThreadPool 线程池

Thread的功能太过强大,像我这样的小白是用不好的(之前在项目中大量使用Thread的API,出现了许多意想不到的bug)。线程池中的线程在同一操作中可以被重复利用。

 //开启多线程  ThreadPool.QueueUserWorkItem(n => DoSomeThing("ThreadPool"));

 个人觉得尽量不要阻塞线程池的线程,因为线程池里的线程数量是有限的,当线程池中没有线程可用时,会出现死锁。如果非要等待,用法如下:

ManualResetEvent manualResetEvent = new ManualResetEvent(false); ThreadPool.QueueUserWorkItem(n => {     DoSomethingLong("ThreadPool");     manualResetEvent.Set(); }); //等待线程完成 manualResetEvent.WaitOne();

 Task

Task是基于ThreadPool的基础上做的封装,属于线程池中的线程。

Task启动多线程的方式:

方式一:指定任务的开始时机

/// <summary> /// 使用Task或Task<T>创建任务,需指定任务的开始时机(任务调度)。 /// </summary> public static void Demo1() {     Task task = new Task(() =>     {         Thread.Sleep(3000); 
Console.WriteLine($"Current thread id is {Thread.CurrentThread.ManagedThreadId}"); }); task.Start();//任务调度(开始任务) Console.WriteLine($"Current thread name is {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"当前任务状态:{task.Status}"); task.Wait(); //等待任务执行完成 Console.WriteLine($"当前任务状态:{task.Status}"); }

 

 

方式二:一步完成多线程的创建和启动

/// <summary> /// 使用Task.Run()方法一步完成多线程的创建和启动(当前线程立即准备启动任务)。 /// <remark> /// 如果不需要对任务的创建和调度做更多操作,Task.Run()方法是创建和启动任务的首选方式。 /// </remark> /// </summary> public static void Demo2() {     Task task = Task.Run(() => { Thread.Sleep(3000); Console.WriteLine($"Current thread id is {Thread.CurrentThread.ManagedThreadId}"); });     task.Wait(); //等待,直到任务完成 }

 

方式三:需要想多线程任务传递状态参数

/// <summary> /// Task和Task<TResult>都有静态属性Factory,它返回默认的实例TaskFactory. /// 使用Task.Factory.StartNew()方法也可以一步完成任务的创建和启动。 /// 当前需要向任务传递一个状态(参数)。可以使用此方法。 /// </summary> public static void Demo3() {     Task[] tasks = new Task[10];     for (int i = 0; i < tasks.Length; i++)     {         tasks[i] = Task.Factory.StartNew((obj) =>         {             CustomData data = obj as CustomData;             data.ThreadId = Thread.CurrentThread.ManagedThreadId;         }, new CustomData { CreationTime = DateTime.Now.Ticks, Index = i});     }
//以阻塞当前线程的方式,等待所以子线程的完成 Task.WaitAll(tasks);
foreach (var task in tasks) { //通过任务的AsyncState属性,可以获取任务状态(提供给任务的参数). var data = task.AsyncState as CustomData; Console.WriteLine(JsonConvert.SerializeObject(data)); } } //Task.Factory.StartNew() 调用无返回值的任务 //Task<TResult>.Factory.StartNew() 调用有返回值的任务

 

Task<TResult>

public static void Demo4() {     Task<Double>[] tasks = { Task<Double>.Factory.StartNew(() => DoComputation(1.0)), Task<Double>.Factory.StartNew(() => DoComputation(100.0)), Task<Double>.Factory.StartNew(() => DoComputation(1000.0)) };     var results = new Double[tasks.Length];     Double sum = 0;     for (int i = 0; i < tasks.Length; i++)     {         //Task<TResult>.Result属性包含任务的计算结果,如果在任务完成之前调用,则会阻塞线程直到任务完成         results[i] = tasks[i].Result;          Console.Write("{0:N1} {1}", results[i],                           i == tasks.Length - 1 ? "= " : "+ ");         sum += results[i];     }     Console.WriteLine("{0:N1}", sum); } private static Double DoComputation(Double start) {     Double sum = 0;     for (var value = start; value <= start + 10; value += .1)         sum += value;     return sum; }

 

Task的常用API

WaitAny和WaitAll,会阻塞当前线程(主线程)的执行:

List<Task> tasks = new List<Task>(); tasks.Add(Task.Run(() => DoSomeThing("Task1"))); tasks.Add(Task.Run(() => DoSomeThing("Task2"))); tasks.Add(Task.Run(() => DoSomeThing("Task3"))); //阻塞当前线程的执行,等待任意一个子线程任务完成后继续往下执行 Task.WaitAny(tasks.ToArray()); //阻塞当前线程的执行,等待所有子线程任务完成后继续往下执行 Task.WaitAll(tasks.ToArray());

 

WhenAll和WhenAny,是通过返回一个Task 对象的方式,来达到非阻塞式的等待

//不阻塞当前线程的执行,等待所有子线程任务完成后,异步执行后续的操作 Task.WhenAll(tasks).ContinueWith(t => {     Console.WriteLine($"不阻塞,{Thread.CurrentThread.ManagedThreadId}"); });  //工厂模式的实现 Task.Factory.ContinueWhenAll(tasks.ToArray(), s => { Console.WriteLine("不阻塞" + s.Length); });

ContinueWith,是一个实例方式,并且返回Task实例,所以可以使用这种链式结构来完成按顺序执行。

public static void Demo8() {     var task = Task.Factory         .StartNew(() => { Console.WriteLine("1"); return 10; })         .ContinueWith(i => { Console.WriteLine("2"); return i.Result + 1; })         .ContinueWith(i => { Console.WriteLine("3"); return i.Result + 1; });     Console.WriteLine(task.Result); }

控制线程数量的使用,(核心思想来自别人,我感觉控制的很好):

/// <summary> /// 线程数量的控制 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Test(object sender, EventArgs e) {     //完成10000个任务,但只要11个线程。     List<int> intList = new List<int>();     for (int i = 0; i < 10000; i++)     {         intList.Add(i);     }     Action<int> action = i =>     {         Console.WriteLine(Thread.CurrentThread.ManagedThreadId);         Thread.Sleep(new Random(i).Next(100, 300));     };     List<Task> tasks = new List<Task>();     foreach (var item in intList)     {         int i = item;         tasks.Add(Task.Run(() => action(i)));         //当已使用了11个线程的时候,即时释放已完成的线程。         if (tasks.Count > 10)         {             Task.WaitAny(tasks.ToArray());             tasks = tasks.Where(n => n.Status != TaskStatus.RanToCompletion).ToList();         }     }     Task.WaitAll(tasks.ToArray()); }

 注意:应当避免在子线程委托的内部直接使用主线程变量(闭包的弊端问题)

 public static void Demo5()  {      Task[] taskArray = new Task[10];      for (int i = 0; i < taskArray.Length; i++)      {          taskArray[i] = Task.Factory.StartNew(() =>          {              //当您使用lambda表达式创建委托时,虽然可以访问变量范围内可见的所有变量。              //但是在某些情况下(最明显的是在循环中),lambda不能像预期的那样捕获变量              //(本例中,它只能捕获最后一个值,而不每次迭代的值)。               //因为任务的运行时机不确定。可以通过传递参数的方式,避免此问题的发生。              Console.WriteLine(i);//输出10个10          });      }      Task.WaitAll(taskArray);  }

创建分离的子任务

  在父任务中创建子任务,如果未指定AttachedToParent选项时,子任务不会与父任务同步。

public static void Demo9() {     //创建父任务     var outer = Task.Run(() =>     {         Console.WriteLine("父任务开始启动!");         //创建子任务         var child = Task.Run(() =>         {             Thread.SpinWait(5000000);             Console.WriteLine("分离的任务完成");         });     });     outer.Wait(); //父任务不会等待子任务的完成     Console.WriteLine("父任务完成."); }

当在任务中运行的代码使用AttachedToParent选项创建新任务时,新任务称为父任务的附加子任务。可以使用AttachedToParent选项来表达结构化任务并行性,因为父任务隐式等待所有附加的子任务完成。

 public static void Demo10()  {      var parent = Task.Factory.StartNew(() => {          Console.WriteLine("Parent task beginning.");          for (int i = 0; i < 10; i++)          {              Task.Factory.StartNew((x) => {                  Thread.SpinWait(5000000);                  Console.WriteLine("Attached child #{0} completed.",x);              }, i, TaskCreationOptions.AttachedToParent);            }      });      parent.Wait();      Console.WriteLine("Parent task completed.");  }

注意:如果父任务启动DenyChildAttach选项,子任务即时启用AttachedToParent选项也不会附加到父任务。

Parallel
parallel为并行计算,主线程也参与计算
 //Parallel.For: public static void Main(string[] args)  {      //计算目录的大小      long totalSize = 0;      String[] files =Directory.GetFiles(@"C:UsersAdministratorDesktop");      Parallel.For(0, files.Length,                   index => {                       FileInfo fi = new FileInfo(files[index]);                       long size = fi.Length;                       Interlocked.Add(ref totalSize, size);  //将两个64位整数相加,并用和替换第一个整数,作为                   });      Console.WriteLine("{0:N0} files, {1:N0} bytes", files.Length, totalSize);   }

//旋转图片  static void Main(string[] args)  {      // A simple source for demonstration purposes. Modify this path as necessary.      string[] files = Directory.GetFiles(@"C:UsersAdministratorDesktoptest");      string newDir = @"C:UsersAdministratorDesktoptestModified";      if (!Directory.Exists(newDir))          Directory.CreateDirectory(newDir);      // Method signature: Parallel.ForEach(IEnumerable<TSource> source, Action<TSource> body)      Parallel.ForEach(files, (currentFile) =>      {          // The more computational work you do here, the greater           // the speedup compared to a sequential foreach loop.          string filename = Path.GetFileName(currentFile);          var bitmap = new Bitmap(currentFile);          bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);          bitmap.Save(Path.Combine(newDir, filename));          // Peek behind the scenes to see how work is parallelized.          // But be aware: Thread contention for the Console slows down parallel loops!!!          Console.WriteLine($"Processing {filename} on thread {Thread.CurrentThread.ManagedThreadId}");          //close lambda expression and method invocation      });  }

 

 分区局部变量

 static void TestParallForeach()  {      int[] array = Enumerable.Range(1, 100).ToArray();      long totalNum = 0;      //int 为集合元素类型      //long 为分区局部变量类型      Parallel.ForEach<int, long>(array, //源集合          () => 0, //初始化局部分区变量,每个分区执行一次          (index, state, subtotal) => //每次迭代的时候执行          {              subtotal += index; //修改分区局部变量              return subtotal; //传递给当前分区的下一次迭代          },          //每个分区结束的时间执行,并将该分区最后一次迭代的局部分区变量传递过来。          (finalTotal) => Interlocked.Add(ref totalNum, finalTotal)          );      /*重载方式:public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source,       Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally);      TSource:源数据类型。 source:源数据,必须实现 IEnumerable<T>接口。      TLocal:局部分区变量类型。localInit:初始化局部分区变量的函数。每个分区都是执行此函数一次。      body:并行循环的每次迭代都是调用此方法。      body.TSource:当前元素。body.ParallelLoopState:ParallelLoopState类型的变量,可用来检索循环的状态。      body.TLocal.1:局部分区变量。      body.TLocal.2:返回值。将其传递给特定分区循环的下一个迭代。      localFinally:每个分区的循环完成时调用此委托。*/      Console.WriteLine(totalNum);

未完待续……

 

赞(0) 打赏
未经允许不得转载:张拓的天空 » C#中异步多线程的常见用法
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

专业的IT技术经验分享 更专业 更方便

联系我们本站主机

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏