C# sync/async 同步/异步(附:进程-线程-多线程--的关系)

------------------------------------进程-线程-多线程------------------------------------------------------------------------------------------------------------------------------------

复制代码
    /// 多线程是.Net开发非常重要的一块儿,
    /// 但是很多开发者工作多年,对多线程几乎不用/很畏惧/不明所以,写代码的时候没有考虑多线程的场景
    /// 
    /// 
    /// 进程:计算机概念,程序在服务器运行时占据全部计算资源综总和
    ///       虚拟的,
    /// 线程:计算机概念,进程在响应操作时最小单位,也包含CPU 内存  网络  硬盘IO
    ///       虚拟的概念,更加看不见摸不着
    /// 一个进程会包含多个线程;线程隶属于某个进程,进程销毁线程也就没了
    /// 句柄:其实是个long数字,是操作系统标识应用程序
    /// 多线程:计算机概念,一个进程有多个线程同时运行
    /// 
    /// C#里面的多线程:
    /// Thread类是C#语言对线程对象的一个封装
    /// 
    /// 为什么可以多线程呢?
    /// 1 多个CPU的核可以并行工作,
    ///   4核8线程,这里的线程指的是模拟核
    ///   
    /// 2 CPU分片,1s的处理能力分成1000份,操作系统调度着去响应不同的任务
    ///   从宏观角度来说,感觉就是多个任务在并发执行
    ///   从微观角度来说,一个物理cpu同一时刻只能为一个任务服务
    /// 
    /// 并行:多核之间叫并行
    /// 并发:CPU分片的并发
    ///   
    /// 同步异步:
    ///       同步方法:发起调用,完成后才继续下一行;非常符合开发思维,有序执行;
    ///                 诚心诚意的请人吃饭,邀请Nick,Nick要忙一会儿,等着Nick完成后,再一起去吃饭
    ///       异步方法:发起调用,不等待完成,直接进入下一行,启动一个新线程来完成方法的计算
    ///                 客气一下的请人吃饭,邀请亡五,亡五要忙一会儿,你忙着我去吃饭了,你忙完自己去吃饭吧
复制代码

什么是进程?

当一个程序开始运行时,它就是一个进程,进程包括运行中的程序和程序所使用到的内存和系统资源。

而一个进程又是由多个线程所组成的。

什么是线程?

线程是程序中的一个执行流,每个线程都有自己的专有寄存器(栈指针、程序计数器等),但代码区是共享的,即不同的线程可以执行同样的函数。

线程和进程的关系?

一个进程会包含多个线程:线程是隶属于某个进程,进程销毁,线程则消失

什么是多线程?

多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务,也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。
多线程的好处: 

可以提高CPU的利用率。在多线程程序中,一个线程必须等待的时候,CPU可以运行其它的线程而不是等待,这样就大大提高了程序的效率。

多线程的不利方面:

线程也是程序,所以线程需要占用内存,线程越多占用内存也越多; 

多线程需要协调和管理,所以需要CPU时间跟踪线程; 

线程之间对共享资源的访问会相互影响,必须解决竞用共享资源的问题;

线程太多会导致控制太复杂,最终可能造成很多Bug;

  何时使用多线程

    多线程程序一般被用来在后台执行耗时的任务。主线程保持运行,并且工作线程做它的后台工作。对于Windows Forms程序来说,如果主线程试图执行冗长的操作,键盘和鼠标的操作会变的迟钝,程序也会失去响应。由于这个原因,应该在工作线程中运行一个耗时任务时添加一个工作线程,即使在主线程上有一个有好的提示“处理中...”,以防止工作无法继续。这就避免了程序出现由操作系统提示的“没有相应”,来诱使用户强制结束程序的进程而导致错误。模式对话框还允许实现“取消”功能,允许继续接收事件,而实际的任务已被工作线程完成。BackgroundWorker恰好可以辅助完成这一功能。

   在没有用户界面的程序里,比如说Windows Service, 多线程在当一个任务有潜在的耗时,因为它在等待另台电脑的响应(比如一个应用服务器,数据库服务器,或者一个客户端)的实现特别有意义。用工作线程完成任务意味着主线程可以立即做其它的事情。

   另一个多线程的用途是在方法中完成一个复杂的计算工作。这个方法会在多核的电脑上运行的更快,如果工作量被多个线程分开的话(使用Environment.ProcessorCount属性来侦测处理芯片的数量)。

   一个C#程序称为多线程的可以通过2种方式:明确地创建和运行多线程,或者使用.NET framework的暗中使用了多线程的特性——比如BackgroundWorker类, 线程池threading timer,远程服务器,或Web Services或ASP.NET程序。在后面的情况,人们别无选择,必须使用多线程;一个单线程的ASP.NET web server不是太酷,即使有这样的事情;幸运的是,应用服务器中多线程是相当普遍的;唯一值得关心的是提供适当锁机制的静态变量问题。

  何时不要使用多线程

    多线程也同样会带来缺点,最大的问题是它使程序变的过于复杂,拥有多线程本身并不复杂,复杂是的线程的交互作用,这带来了无论是否交互是否是有意的,都会带来较长的开发周期,以及带来间歇性和非重复性的bugs。因此,要么多线程的交互设计简单一些,要么就根本不使用多线程。除非你有强烈的重写和调试欲望。

当用户频繁地分配和切换线程时,多线程会带来增加资源和CPU的开销。在某些情况下,太多的I/O操作是非常棘手的,当只有一个或两个工作线程要比有众多的线程在相同时间执行任务快的多。

------------------------------------C# sync/async 同步/异步------------------------------------------------------------------------------------------------------------------------------------

一:同步方法:

在程序继续执行之前需要等待同步方法执行完毕返回结果

通俗的例子就是: 邀请wss次饭,wss要忙一会儿,邀请人等着wss完成后,再一起去吃饭,这就是所谓的诚心诚意的请人吃饭。下面我通过代码来举例来说明一下同步方法:

复制代码
/// <summary>
/// 一个比较耗时耗资源的私有方法
/// </summary>
/// <param name="name"></param>
private void DoSomethingLong(string name)
{
    Console.WriteLine($"******DoSomethingLong Start  {name}  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}*******");
    long lResult = 0;
    for (int i = 0; i < 1_000_000_000; i++)
    {
        lResult += i;
    }
    Console.WriteLine($"*****DoSomethingLong   End  {name}  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}*********");
}

/// <summary>
/// 同步方法
/// </summary>
private void syncWay()
{
    Console.WriteLine($"******同步方法开始执行,执行线程ID:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】,执行开始时间:【 {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}】*****");
    for (int i = 0; i < 5; i++)
    {
        string name = string.Format($"sysnc_{i}");
        this.DoSomethingLong(name);
    }
    Console.WriteLine($"****同步方法执行结束,执行线程ID:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】,执行开始时间:【 {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}】******");
}
复制代码

直接调用执行 syncWay(); 则会输出如下图:

 

我们可以通过上图晓得:DoSomethingLong是一步一步执行的,而且同步方法的线程Id都是一致的,也可以看出执行过程的耗时也蛮长。

二:异步方法:

在被调用之后立即返回以便程序在被调用方法完成其任务的同时执行其它操作

通俗的例子就是: 邀请wss次饭,wss要忙一会儿,然后wss自己先忙着吧,邀请人先去吃饭了,wss忙完自己去吃饭吧,这就是所谓的客气一下的请人吃饭。下面我接着使用实例来认识异步方法:

复制代码
/// <summary>
/// 一个比较耗时耗资源的私有方法
/// </summary>
/// <param name="name"></param>
private void DoSomethingLong(string name)
{
    Console.WriteLine($"*****DoSomethingLong开始;参数【{name}】;线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】;当前时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***");
    long result = 0;
    for (int i = 0; i < 1_000_000_000; i++)
    {
        result += i;
    }
    Console.WriteLine($"*****DoSomethingLong结束;参数【{name}】;线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】;当前时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")};result:{result}***");
}

private void AsyncWay()
{
    Console.WriteLine($"******异步方法开始执行,执行线程ID:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】,执行开始时间:【 {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}】*****");
    Action<string> action = this.DoSomethingLong;
    for (int i = 0; i < 5; i++)
    {
        string name = string.Format($"async_{i}");                
        action.BeginInvoke(name, null, null);//委托自身需要的参数 + 2个异步参数(这两个参数我们在下面详细说明)
    }
    Console.WriteLine($"****异步方法执行结束,执行线程ID:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】,执行开始时间:【 {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}】******");
}
复制代码

然后通过执行AsyncWay()这个方法,会得到如下截图:

 我们可以通过上面的图得到如下几点:

1:不卡主线程改善用户体验。web或者winform如果处理耗时的任务,异步方法会使页面或者winform不卡界面,这主要是主线程(线程01)闲置,计算任务交给子线程(线程03,04,05,06)完成。这个可以改善用户体验。一般在web应用中异步方法会做发短信/记日志等功能。

2:异步方法耗时短,这个是最明显的。通过我们观察cpu的曲线图,会总结出:多线程其实是资源换性能。但是也不能乱用多线程,主要是

  • A: 资源不是无限的 
  • B: 资源调度损耗(这个电脑配置有关系)

3:异步方法是无序的,主要体现在如下:

  • A:启动无序,因为线程资源是向操作系统申请的,由操作系统的调度策略决定,所以启动顺序随机
  • B:同一个任务同一个线程,执行时间也不确定,CPU分片
  • C:由上面两条也得到结束也无序

.NET Framework 允许异步调用任何方法。定义与您需要调用的方法具有相同签名的委托;公共语言运行库将自动为该委托定义具有适当签名的 BeginInvoke 和 EndInvoke 方法。
BeginInvoke 方法用于启动异步调用。它与您需要异步执行的方法具有相同的参数,只不过还有两个额外的参数

      • 第一个参数表示一个委托,需要传递一个方法,当该线程结束时会调用这个方法
      • 第二个参数可以设置为任意对象,以便在回调函数中访问它,在这里所用的是上面定义的委托a。

三:异步方法如何控制顺序?

就是说我们想要在一个异步方法全部执行完成后再执行某一部分内容,可以通过以下几种方式来实现:

1:BeginInvoke

立即返回,不等待异步调用完成。

使用BeginInvoke的AsyncCallback,将后续动作通过回调参数AsyncCallback传递进去,子线程完成计算后,去调用这个回调委托,BeginInvoke这个我们上面有提到,下面还是以代码来解释说明。

复制代码
private void FirstWay()
{
    Console.WriteLine($"**开始线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");

    Action<string> action = this.DoSomethingLong;
    IAsyncResult asyncResult = null;//是对异步调用操作的描述
  
    //回调委托方法:将后续动作通过回调参数传递进去,子线程完成计算后,去调用这个回调委托
    AsyncCallback callback = ar =>
    {
        Console.WriteLine($"asyncResult和ar是否是同一个对象:{object.ReferenceEquals(ar, asyncResult)}"); //可以说明ar就是asyncResult
        Console.WriteLine($"dosomething计算成功了。ar.AsyncState=【{ar.AsyncState}】。线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
    };
    //第1个参数:是action需要的参数;
    //第2个参数:AsyncCallback,就是执行完action方法后要执行的内容;
    //第3个参数:是一个object的对象,指的是IAsyncResult函数中的AsyncState,可以作为参数等传进去
    asyncResult = action.BeginInvoke("异步控制顺序", callback, "ar.AsyncState参数");
    Console.WriteLine($"**结束:线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");
}
复制代码

执行FirstWay()会得到如下结果:

我们通过上图可以分析出:

  • A:BeginInvoke是一个异步方法,因为主线程【01】只负责打印,而DoSomethingLong这个方法是开启一个新的线程【03】执行
  • B:AsyncCallback这个委托的参数其实是 action.BeginInvoke返回的结果类型为IAsyncResult,就是例子中的asyncResult
  • C:action.BeginInvoke第三个参数就是IAsyncResult中的AsyncState,是一个object类型,可以作为参数传入到AsyncCallback函数中
  • D:action.BeginInvoke这个函数的执行顺序是:先执行Action函数,然后执行完返回一个IAsyncResult结果asyncResult,然后把asyncResult作为参数传入到AsyncCallback这个委托中,最后再执行AsyncCallback委托

2:BeginInvoke 返回 IasyncResult,属性IAsyncResult.IsCompleted

可用于监视调用进度。

复制代码
private void SecondWay()
 {
     Console.WriteLine($"**开始线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");
     Action<string> action = this.DoSomethingLong;
     IAsyncResult asyncResult = action.BeginInvoke("异步控制顺序", null, null);

     //通过IsComplate等待,卡界面--主线程在等待,边等待边提示
     int i = 0;
     while (!asyncResult.IsCompleted)
     {
         if (i < 9)
         {
             Console.WriteLine($"DoSomethingLong完成{++i * 10}%....");
         }
         else
         {
             Console.WriteLine($"DoSomethingLong完成99.999999%....");
         }
         Thread.Sleep(300);
     }
     Console.WriteLine("DoSomethingLong完全执行结束!");
     Console.WriteLine($"**结束:线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");
 }
复制代码

执行SecondWay()会返回如下:

 

3:使用 WaitOne等待,

即时等待  限时等待,示例代码如下:

复制代码
private void ThirdWay()
 {
     Console.WriteLine($"**开始线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");
     Action<string> action = this.DoSomethingLong;
     IAsyncResult asyncResult = action.BeginInvoke("第三种异步控制顺序", null, null);
     asyncResult.AsyncWaitHandle.WaitOne();//直接等待任务完成
     //asyncResult.AsyncWaitHandle.WaitOne(-1);//一直等待任务完成
     //asyncResult.AsyncWaitHandle.WaitOne(1000);//最多等待1000ms,超时就不等了

     Console.WriteLine("DoSomethingLong完全执行结束!");
     Console.WriteLine($"**结束:线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");
 }
复制代码

执行 ThirdWay()得到以下结果:

 

 

4:使用EndInvoke :

即时等待,而且可以获取委托的返回值 一个异步操作只能End一次,示例代码如下:

EndInvoke 方法用于检索异步调用结果。调用 BeginInvoke 后可随时调用 EndInvoke 方法;如果异步调用未完成,EndInvoke 将一直阻塞到异步调用完成。
EndInvoke 的参数包括您需要异步执行的方法的 out 和 ref 参数(在 Visual Basic 中为 <Out> ByRef 和 ByRef)以及由BeginInvoke 返回的 IAsyncResult。

复制代码
private void ForthWay()
{
    Console.WriteLine($"**开始线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");

    Action<string> action = this.DoSomethingLong;
    IAsyncResult asyncResult4Action = action.BeginInvoke("第四种EndInvoke异步控制顺序", null, null);
    action.EndInvoke(asyncResult4Action);


    Func<int> func = () => { return 10; };
    IAsyncResult asyncResult4Fun = func.BeginInvoke(ar => 
    {
        Console.WriteLine($"IAsyncResult中的线程Id:【{ Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
    }, null);
    int result=func.EndInvoke(asyncResult4Fun);//里面的参数不能为空

    Console.WriteLine($"endInvoke返回的func委托的值:{result}");
    Console.WriteLine("DoSomethingLong完全执行结束!");
    Console.WriteLine($"**结束:线程Id:【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}**");
}
复制代码

执行ForthWay()会得到如下:

上面的代码有Action和Fun两个方法,然后执行有时候会出现上图的结果,IAsyncResult最后一个输出来,通过这个我们可以得知: EndInvoke是让主线程的动作,等着子线程完成,但是这个等待并不会等待回调函数。所以会出现上面的结果

说明:以上四种方法中DoSomethingLong这个函数我们都使用上面异步或者同步方法的示例

 通过以上4种方法总结得出,使用 BeginInvoke 和 EndInvoke 进行异步调用的常用方法。调用了 BeginInvoke 后,可以:

  1. 进行某些操作,然后调用 EndInvoke 一直阻塞到调用完成。
  2. 使用 IAsyncResult.AsyncWaitHandle 获取 WaitHandle,使用它的 WaitOne 方法将执行一直阻塞到发出 WaitHandle 信号,然后调用EndInvoke。这里主要是主程序等待异步方法,等待异步方法的结果。
  3. 轮询由 BeginInvoke 返回的 IAsyncResult,IAsyncResult.IsCompeted确定异步调用何时完成,然后调用 EndInvoke。此处理个人认为与相同。
  4. 将用于回调方法的委托传递给 BeginInvoke。该方法在异步调用完成后在 ThreadPool 线程上执行,它可以调用 EndInvoke。这是在强制装换回调函数里面IAsyncResult.AsyncState(BeginInvoke方法的最后一个参数)成委托,然后用委托执行EndInvoke。
  5. 警告 始终在异步调用完成后调用 EndInvoke。

微软文档:

IAsyncResult:https://docs.microsoft.com/zh-cn/dotnet/api/system.iasyncresult?view=netframework-4.8

AsyncCallback:https://docs.microsoft.com/zh-cn/dotnet/api/system.asynccallback?view=netframework-4.8

感谢软谋教育Eleven老师!!
posted @   明志德道  阅读(2765)  评论(0编辑  收藏  举报
编辑推荐:
· 浏览器原生「磁吸」效果!Anchor Positioning 锚点定位神器解析
· 没有源码,如何修改代码逻辑?
· 一个奇形怪状的面试题:Bean中的CHM要不要加volatile?
· [.NET]调用本地 Deepseek 模型
· 一个费力不讨好的项目,让我损失了近一半的绩效!
阅读排行:
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
· 浏览器原生「磁吸」效果!Anchor Positioning 锚点定位神器解析
点击右上角即可分享
微信分享提示