C# 异步（Task）与线程（Thread/ThreadPool）async Task await

KingCruel

已于 2023-10-12 22:11:56 修改

阅读量1.9k

点赞数

分类专栏： .Net技术 .NET Core 文章标签： async Task await

于 2016-12-19 11:33:34 首次发布

本文链接：https://blog.csdn.net/KingCruel/article/details/53737217

版权

.Net技术同时被 2 个专栏收录

88 篇文章 1 订阅

订阅专栏

.NET Core

76 篇文章 7 订阅

订阅专栏

Task 官网（Docs Microsoft）
Task 类（NET 7）
Task.Factory 属性
 异步编程
 ThreadPool 类

在C#中，使用Task可以很方便地执行并行任务。Task是一个表示异步操作的类，它提供了一种简单、轻量级的方式来创建多线程应用程序。

Task执行并行任务的原理
使用Task执行并行任务的原理是将任务分成多个小块，每个小块都可以在不同的线程上运行。然后，使用Task.Run方法将这些小块作为不同的任务提交给线程池。线程池会自动管理线程的创建和销毁，并根据系统资源的可用情况来自动调整线程数量，从而实现最大化利用CPU资源的效果。

● Task.Run(() => { });
● Task.Factory.StartNew(() => { });
● Task.Factory.ContinueWhenAll(new[] { task1, task2, task3 }, tasks =>
{
foreach (Task<string> task in tasks)
{
Console.WriteLine(task.Result);
}
});
● Task.WhenAll( // 所有提供的任务已完成时，创建将完成的任务
Task.Run(() => { }),
Task.Run(() => { })
);
● Task.WhenAny( // 任何提供的任务已完成时，创建将完成的任务
Task.Run(() => { }),
Task.Run(() => { })
);
● Task.WaitAll( // 等待所有Task任务执行完毕，才会继续进行
Task.Run(() => { }),
Task.Run(() => { })
);
● Task.WaitAny(  // 等待任一Task任务执行完毕，而不需要等待所有Task任务执行完毕
Task.Run(() => { }),
Task.Run(() => { })
);
● Task.Delay(100); //创建将在时间延迟后完成的任务
● t.Start(); //启动Task
● t.Wait(); //等待Task完成执行过程
● Task.Yield(); //创建异步产生当前上下文的等待任务
● t.RunSynchronously()

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Mvc;

namespace Web.Controllers
{
    public class HomeController : Controller
    {
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public async Task<int> MethodAsync()
        {
            var today = await Task.FromResult<string>(DateTime.Now.DayOfWeek.ToString());

            int leisureHours;
            if (today.First() == 'S')
                leisureHours = 16;
            else
                leisureHours = 5;

            return leisureHours;
        }

        /// <summary>
        /// 异步打印传入的字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public async Task<string> AsyncPringString(string str)
        {
            return await Task.FromResult<string>("刘德华");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public async Task<string> ss()
        {
            return await Task.Run(() => PrintString());
        }

        /// <summary>
        /// 多线程执行后，执行另一个方法
        /// </summary>
        public void a()
        {
            var task1 = Task.Factory.StartNew(() => PrintString()).ContinueWith(
                task => { Console.WriteLine(task.Result.ToString()); }).ContinueWith(
                task => { Console.WriteLine("结束"); });
        }

        /// <summary>
        /// 等待所有线程结束
        /// </summary>
        public void b()
        {
            var task1 = Task.Factory.StartNew(() => PrintString());
            var task2 = Task.Factory.StartNew(() => PrintString());
            var task3 = Task.Factory.StartNew(() => PrintString());
            Task.WaitAll(task1, task2, task3);
        }

        /// <summary>
        /// 等待其中一个线程结束
        /// </summary>
        public void c()
        {
            var task1 = Task.Factory.StartNew(() => PrintString());
            var task2 = Task.Factory.StartNew(() => PrintString());
            var task3 = Task.Factory.StartNew(() => PrintString());
            Task.WaitAny(task1, task2, task3);
        }

        /// <summary>
        /// 等待所有线程结束执行的方法
        /// </summary>
        public void d()
        {
            var task1 = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(3000);
                return "dummy value 1";
            });

            var task2 = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(3000);
                return "dummy value 2";
            });

            var task3 = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(3000);
                return "dummy value 3";
            });

            Task.Factory.ContinueWhenAll(new[] { task1, task2, task3 }, tasks =>
            {
                foreach (Task<string> task in tasks)
                {
                    Console.WriteLine(task.Result);
                }
            });
        }


        private string PrintString()
        {
            return "Hello World!";
        }
    }
}

2、在非异步api接口，调用异步方法（）

 [HttpGet()]
 public IEnumerable<WeatherForecast> Get()
 {
   #region Wait()
   Task task = Task.Factory.StartNew(() =>
   {
     response = serviceClient.TestAsync(request).Result;
   });
   task.Wait();
   #endregion

   #region WaitAny
   //var task = Task.Factory.StartNew(() =>
   // response = serviceClient.TestAsync(request).Result
   //);
   //Task.WaitAny(task);
   #endregion

   #region Run Wait
   //Task.Run(() => response = serviceClient.TestAsync(request).Result).Wait();
   #endregion

   var rng = new Random();
   return Enumerable.Range(1, 5).Select(index => new WeatherForecast
   {
     Date = DateTime.Now.AddDays(index),
     TemperatureC = rng.Next(-20, 55),
     Summary = Summaries[rng.Next(Summaries.Length)],
     Test = response.Body.TestResult
   }).ToArray();
 }

3、在异步方法中，调用异步方法

[HttpGet()]
public async Task<string> Get()
{
  var result = await serviceClient.TestAsync(request);
  return result.Body.TestResult;
}

4、Thread
无参数

public ActionResult FreeCallBack()
{
    try
    {
        Thread thread1 = new Thread(new ThreadStart(test));
        thread1.IsBackground = true;
        thread1.Start();
    }
    catch (Exception)
    {
    }
    return View();
}

void test()
{
}

有参数

public ActionResult FreeCallBack()
{
    try
    {
        string conferenceid = "123456";
        Thread thread = new Thread(new ParameterizedThreadStart(Monitor));
        thread.IsBackground = true;
        thread.Start(conferenceid);
    }
    catch (Exception)
    {
    }
    return View();
}

void Monitor(object conferenceid)
{
}

5、ThreadPool 线程池
ThreadPool 类

一个应用程序最多只能有一个线程池；
ThreadPool静态类通过QueueUserWorkItem()方法将工作函数排入线程池；
每排入一个工作函数，就相当于请求创建一个线程；
通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。

属性
CompletedWorkItemCount：获取迄今为止已处理的工作项数。
PendingWorkItemCount：获取当前已加入处理队列的工作项数。
ThreadCount：获取当前存在的线程池线程数。

方法
SetMaxThreads(Int32, Int32)：设置可以同时处于活动状态的线程池的请求数目。所有大于此数目的请求将保持排队状态，直到线程池线程变为可用。
SetMinThreads(Int32, Int32)：发出新的请求时，在切换到管理线程创建和销毁的算法之前设置线程池按需创建的线程的最小数量（最少存活的线程的数量）。
GetMaxThreads(Int32, Int32)：检索可以同时处于活动状态的线程池请求的数目。所有大于此数目的请求将保持排队状态，直到线程池线程变为可用。
GetMinThreads(Int32, Int32)：发出新的请求时，在切换到管理线程创建和销毁的算法之前检索线程池按需创建的线程的最小数量。
QueueUserWorkItem(WaitCallback)：将方法排入队列以便执行。此方法在有线程池线程变得可用时执行。
QueueUserWorkItem(WaitCallback, Object)：将方法排入队列以便执行，并指定包含该方法所用数据的对象。此方法在有线程池线程变得可用时执行。
*
*
*