C#多线程学习 十四：同步 VS 异步

最新推荐文章于 2022-05-13 10:38:32 发布
最新推荐文章于 2022-05-13 10:38:32 发布
阅读量485 收藏
点赞数
分类专栏： 默认 文章标签： 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43542114/article/details/108995383
版权

同步 VS 异步

  1. 同步操作会返回调用者之前完成它的工作。
  2. 异步操作会在返回调用者之后去做它的大部分工作。
  3. 异步的方法为少见 ， 会启用并发，因为它的工作会与调用者并行执行。
  4. 异步方法通常很快（立即） 就会返回调用者 ， 所以叫非阻塞方法。
  5. 目前见到的大部分的异步方法都是通用目的：
    Thread.Start Task.Run 可以将Continuation 附加到Task的方法。

什么是异步编程？

  1. 异步编程的原则是将长时间运行的函数写成异步的。
  2. 传统的做法是 将长时间的运行的函数写成同步，然后从新的线程或者Task 进行调用，从而按需引用。
  3. 上述异步方式的不同之处在于，他是从长时间运行函数的 内部启用并发，还有两点好处：
    IO-bound 并发可不使用线程来实现。可以提高可拓展性和执行效率。 富客户端在worker 线程会使用更少的代码， 简化了线程安全性。

异步编程的两种用途

  1. 编写高效处理大量并发IO 的应用程序（典型的：服务器应用）
    挑战并是线程安全（因为共享状态通常是最小化的）， 而是执行效率，特别是网络请求并不会消耗一个线程。

  2. 在富客户端应用简化线程安全。 如果调用图中任何一个操作是是长时间运行， 那么整个call graph 必须运行在 worker 线程上， 以保证UI响应。
    得到一个横跨多个方法的单一并发操作(颗粒度)。 需要为call graph 中每个方法考虑线程安全。 异步的call graph ， 直到需要才开启一个线程，通常比较浅（IO-bound 操作完全不需要）

经验之谈：

  1. 为了获取上述好处，下列操作建议异步编程。
    IO-bound 和 Compute-bound 操作。
    执行操作时间超过了50ms。
  2. 另一边面过细的颗粒度会损害性能，因为异步操作也会有开销。

异步编程和Continuation

  1. Task 非常适合异步编程，因为他们支持Continuation （他对异步非常重要）
    TaskCompletionSource 的例子。
  2. 对于 Compute-bound 方法，Task.Run 会初始化绑定线程并发。
    把task 返回调用者 创建异步方法。
    异步编程的区别：目标是在调用图比较浅的位置。
    富客户端应用中，高级方法可以保留在UI线程和访问控制及共享状态上， 不会出现线程安全问题。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp4
{
class Program
{
static void Main(string[] args)
{
DisplayPrimeCount();

        //Task.Run(()=> { DisplayPrimeCount(); });
        Console.ReadKey();
    }

    static void DisplayPrimeCount()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(GetPrimesCount(i * 100000 + 2, (i + 1) * 100000 - 1) + " primes between " + (i * 100000) + " and "+((i + 1) * 100000 - 1));
        }
        Console.WriteLine("Done");
    }

    static int GetPrimesCount(int start, int count)
    {
        return ParallelEnumerable.Range(start, count).Count(Ret =>
            Enumerable.Range(2, (int)Math.Sqrt(Ret) - 1).All(i => Ret % i > 0)

        ); 
    }
}

}

for text two

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp4
{
class Program
{
static void Main(string[] args)
{
// DisplayPrimeCount();

        Task.Run(()=> { DisplayPrimeCount(); });

        Console.ReadKey();
    }

    static void DisplayPrimeCount()
    {
        //for (int i = 0; i < 10; i++)
        //{
        //    Console.WriteLine(GetPrimesCount(i * 100000 + 2, 1000000) + " primes between " + (i * 100000) + " and "+((i + 1) * 100000 - 1));
        //}

        for (int i = 0; i < 10; i++)
        {
            var awaiter = GetPrimesCountAsync(i * 100000 + 2, (i + 1) * 100000 - 1).GetAwaiter();
            awaiter.OnCompleted(() => {
                Console.WriteLine(awaiter.GetResult() + " primes between " + (i * 100000) + " and " + ((i + 1) * 100000 - 1));
            });

        }

        Console.WriteLine("Done");
    }

    static Task<int> GetPrimesCountAsync(int start, int count)
    {
        return Task<int>.Run(()=> ParallelEnumerable.Range(start, count).Count(Ret =>
            Enumerable.Range(2, (int)Math.Sqrt(Ret) - 1).All(i => Ret % i > 0)
        )); 
    }
}

}

语言对异步的支持是非常重要的

  1. 需要对task 的执行进行序列化， 例如 taskB 依赖于taskA 的执行结果，。
  2. 为此 ， 必须在Continuation 内部触发下一次循环，
  3. async 和 await 对于不想复杂的实现异步是非常重要的，命令式循环结构不要和continuation 混合在一起， 应为他们依赖当前本地状态。
  4. 另一种实现， 函数式写法（linq查询） ， 他们也是 响应式编程（rx）的基础。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp4
{
class Program
{
static void Main(string[] args)
{
// DisplayPrimeCount();

        Task.Run(()=> { DisplayPrimeCount(); });

        Console.ReadKey();
    }

    static void DisplayPrimeCount()
    {
        DisplayPrimeCountFrom(0);
    }

    static void DisplayPrimeCountFrom(int start)
    {
      TaskAwaiter<int> awaiter=  GetPrimesCountAsync(start * 1000000 + 2, 1000000).GetAwaiter();
        awaiter.OnCompleted(() => {
            Console.WriteLine(awaiter.GetResult()+"\t"+start);
            if (start++<10)
            {
                DisplayPrimeCountFrom(start);
            }
        });
    }

    static Task<int> GetPrimesCountAsync(int start, int count)
    {
        return Task<int>.Run(()=> ParallelEnumerable.Range(start, count).Count(Ret =>
            Enumerable.Range(2, (int)Math.Sqrt(Ret) - 1).All(i => Ret % i > 0)
        )); 
    }
}

}

异步函数

async和 await 关键字 可以让你写出和同步代码一样的简介异步代码。

awaiting
await 关键字简化了附加continuation 的过程。
其结构如下： var result = await expression； statement（s）;
它的作用相当于：
var awaiter= expression . GetAwaiter（）；
awaiter.OnCompleted(()=>{
var result=awaiter.GetResult();
statemnet(S);
});

async 修饰符

  1. async 修饰符会让编译器把await 当做关键字而不是标识符（C#5.0 以前可能会使用await 作为修饰符）
  2. async修饰符 只能适用于方法（包括lambda表达式）。 该方法可以返回void task task
  3. async 修饰符对方法签名和pubic 元素数据没有影响（和 unsafe 一样） 他只会影响方法内部。
  4. 在接口内部使用async是没有任何意义的。 使用async 来重载非async 的方法是合法的（只要方法签名一致）使用async 修饰符的方法就是“异步函数”

异步方法如何执行

  1. 遇到await 表达式，执行（正常情况下） 会返回调用者，就像iterator里边的 yield return。 再返回前 运行时会附加一个continuation 从停止的地方继续执行。
  2. 如果发生故障，那么异常会重新抛出。如果一切正常，那么他的返回值就会赋值给await 表达式。

可以 await 什么？

  1. 你await 的表达式通常是一个task。
  2. 也可以满足下列条件的任意对象： 有GetAwaiter方法，他返回一个awaiter。 返回适合类型的GetResult方法。 有一个bool类型的IsCompleted属性。

捕获本地状态：

  1. await 表达式的最牛之处 就是他几乎可以出现在任何地方。
  2. 特别的， 在异步方法内，await表达式可以替换任何表达式。
    除了lock 和 unsafe 上下文。

await 之后在哪个线程上执行

  1. await 表达式之后，编译器依赖于continuation（通过阿waiter模式） 来继续执行。
  2. 如果在富客户端应用的UI线程上，同步上下文会保证后续是在原线程上执行。否则， 就会在task 结束的线程上继续执行。

UI上的await

  1. 本例子中，只有GetPrimesCounAsync中的代码在worker 线程上执行，
  2. Go中的代码会租用UI线程上的时间。可以说：Go是在消息循环中 伪并发 的执行。也就是说：他和UI线程处理其他事件是穿插执行的。
  3. 因为这种伪并发， 唯一能发生强占的时刻就是在await 期间。 这其实简化了线程安全， 防止重复进入即可。
  4. 这种并发发生在调用栈较浅的地方（Task.Run 调用的代码）
  5. 为了从该模型获益，真正的并发代码要避免访问共享状态或UI控件。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

    void Go()
    {
        for (int i = 0; i < 100; i++)
        {
            textBox1.Text += GetPrimesCount(i + 100000, 100000).ToString()+Environment.NewLine;
        }
    }

    private int GetPrimesCount(int v1, int v2)
    {
        return ParallelEnumerable.Range(v1, v2).Count(ret =>
        {
          return   Enumerable.Range(2, (int)Math.Sqrt(ret) - 1).All(n => ret % n > 0);
        });
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        button1.Click += (_sender, _e) => Go();
    }
}

}

上面的例子是同步方法容易卡死UI主界面。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

   async void Go()
    {
        button1.Enabled = false;
        for (int i = 0; i < 100; i++)
        {
            textBox1.Text += await GetPrimesCountAsync(i + 1000000, 100000) + Environment.NewLine;
        }
        button1.Enabled = true;
    }

    private Task<int> GetPrimesCountAsync(int v1, int v2)
    {
        return Task<int>.Run(() => ParallelEnumerable.Range(v1, v2).Count(ret =>
    {
        return Enumerable.Range(2, (int)Math.Sqrt(ret) - 1).All(n => ret % n > 0);
    }));

    }

    private void Form1_Load(object sender, EventArgs e)
    {
        button1.Click += (_sender, _e) =>  Go();
    }
}

}

与颗粒度的并发相比

  1. 例如使用BackgroundWorker （例子， Task.Run）。 整个同步调用图都在worker 线程上。 必须在代码中到处使用Dispatcher.BeginInvoke
  2. 循环本身在worker 线程上。 引入 race condition 。 若实现取消和过程报告，会使得线程安全问题更容易发生，在方法中新添加任何的代码也是同样的效果。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

   async void Go()
    {
        button1.BeginInvoke(new Action(() => { button1.Enabled = false; }));
        

        for (int i = 0; i < 100; i++)
        {
            int retNu= await GetPrimesCountAsync(i + 1000000, 100000) ;
            textBox1.BeginInvoke(new Action(() => { textBox1.Text += retNu + Environment.NewLine; }));
        }

        button1.BeginInvoke(new Action(() => { button1.Enabled = true; }));
    }

    private Task<int> GetPrimesCountAsync(int v1, int v2)
    {
        return Task<int>.Run(() => ParallelEnumerable.Range(v1, v2).Count(ret =>
    {
        return Enumerable.Range(2, (int)Math.Sqrt(ret) - 1).All(n => ret % n > 0);
    }));

    }

    private void Form1_Load(object sender, EventArgs e)
    {
        button1.Click += (_sender, _e) =>Task.Run(()=> Go());
    }

   

    private void button1_Click(object sender, EventArgs e)
    {
       
    }
}

}

望天hous
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
c#线程同步与异步编程
05-13
通过实例说明c#中同步和异步的区别，适合于初学者，能够帮助理解同步和异步的概念。
C#委托的异步调用[学习]
weixin_34301132的博客
11-07 279
本文将主要通过“同步调用”、“异步调用”、“异步回调”三个示例来讲解在用委托执行同一个“加法类”的时候的的区别和利弊。 首先，通过代码定义一个委托和下面三个示例将要调用的方法： /*添加的命名空间 using System.Threading; using System.Runtime.Remoting.Messaging; */     public delegate int...
C# 线程同步与线程异步
qq_39530324的博客
07-06 1113
1.线程同步： 研究对象： 来自Thread类的构造器委托参数 1.1 没有参数且无返回值的委托，代码实例： Thread threadStart=new Thread(new ThreadStart( ()=> { for(var i=0;i<1000000;i++) { Console.WriteLine(“后台线程计数”+i); } })); threadStart.IsBack...
C#多线程及同步异步简介
HinataHazuki的博客
07-06 602
详细介绍推荐该博客：https://www.cnblogs.com/wwj1992/p/5976096.html1、多线程分为主线程、前台线程和后台线程。①主线程：CLR（公共语言执行库）为进程自动创建。②前台线程：自行创建线程时默认都为前台线程，前台线程全都运行完毕应用程序才可以退出。（进程的亲儿子）③后台线程：通过Thread.IsBackground = true设置，关闭程序时所有后台线程...
C# 同步和异步
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
08-17 6111
一、同步 同步概念大家都很熟悉。在异步概念出来之前，我们的代码都是按同步的方式写的。简单来说，就是程序严格按照代码的逻辑次序，一行一行执行。 看一段代码： public static void Main(string[] args) { Console.WriteLine("Syc proccess - start"); Console.WriteLine("Syc proccess - enter Func1"); func1(); Console.WriteLine("
C#.net同步异步SOCKET通讯和多线程总结
10-06
C#.net同步异步SOCKET通讯和多线程总结~
解析C#多线程编程中异步多线程的实现及线程池的使用
09-02
主要介绍了C#多线程编程中异步多线程的实现及线程池的使用,同时对多线程的一般概念及C#中的线程同步并发编程作了讲解,需要的朋友可以参考下
C#实现多线程的同步方法详解
01-31
C#简单多线程同步和优先权用法实例
09-04
主要介绍了C#简单多线程同步和优先权用法实例,对于C#线程的阻塞、同步、异步、互斥等概念做了较为深入的分析与实例讲解,需要的朋友可以参考下
详解C#多线程之线程同步
01-21
通过学习《CLR via C#》里面的内容，对线程同步形成了脉络较清晰的体系结构，在多线程中实现线程同步的是线程同步构造，这个构造分两大类，一个是基元构造，一个是混合构造。所谓基元则是在代码中使用最简单的构造。...
C#多线程同步与异步的实现[归纳].pdf
10-19
C#多线程同步与异步的实现[归纳].pdf
C#多线程与异步的区别详解
12-31
C#多线程与异步的区别详解 随着拥有多个硬线程 CPU（超线程、双核）的普及，多线程和异步操作等并发程序设计方法也受到了更多的关注和讨论。本文主要是想与各位高手一同探讨一下如何使用并发来最大化程序的性能。 多线程和异步操作的异同 多线程和异步操作两者都可以达到避免调用线程阻塞的目的，从而提高软件的可响应性。甚至有些时候我们就认为多线程和异步操作是等同的概念。但是，多线程和异步操作还是有一些区别的。而这些区别造成了使用多线程和异步操作的时机的区别。 异步操作的本质 所有的程序最终都会由计算机硬件来执行，所以为了更好的理解异步操作的本质，我们有必要了解一下它的硬件基础。 熟悉电脑硬件的朋友
【C#同步与异步】
qq_43868802的博客
05-13 1100
C#的异步与同步详解
C#中异步方法和同步方法对比
成长中の稻草人
07-09 1199
针对于Winform来说 同步方法： 1、卡界面，主线程忙于计算，无法顾及其他任务。 2、执行速度慢，由于只有一个线程进行计算。 3、有序执行任务 异步方法： 1、不卡界面，主线程闲置（可进行其他操作），计算机待办任务交由子线程来完成，改善用户体验。 2、异步多线程执行速度快，可开启多个线程同时进行任务操作。 3、无序执行计算机任务，启动无序：线程资源是向操作系统申请的，由操作系统的调度策略决定，所以启动顺序随机， 同一个任务同一个线程，执行时间也不确定，CPU分片，结束也无序 ..
同步VS异步
yangyan525的博客
12-18 207
1.同步和异步 ：通常形容一次方法调用。 2.区别： 同步：（强制依赖对方）同步方法调用就是方法调用一旦开始，调用者必须得到回复，才能进行下一步响应。也就是说，同步的操作是顺序执行，中间少了哪一步都不可以，或者哪一步出错也不可以。同时，如果一直没有等到回复，则一直处于阻塞状态。 异步：（不强制依赖）异步调用一旦开始，无论你返不返回，我都继续执行。如果你响应并返回了，我就继续做之前的事；如果你...
同步 vs 异步
xiao123456bin的博客
04-27 192
操作系统中： 在进行网络编程时，我们常常见到同步、异步、阻塞和非阻塞四种调用方式。这些方式彼此概念并不好理解。下面是我对这些术语的理解。 同步 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。按照这个定义，其实绝大多数函数都是同步调用（例如sin, isdigit等）。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。最常见的例子就...
C#之同步、异步、多线程
时间蜗牛的博客
02-25 2453
C#之同步、异步、多线程今天我们来一起学习C#中的同步。异步以及多线程。在学习这些之前，我们先来简单地了解下进程和线程之间的关系，一个应用程序即一个进程，而一个进程的执行需要多个线程来辅助，所以运行一个进程后，会运行多个线程。所谓的同步，即按照代码的顺序执行，也就是用同一个线程来执行所有的操作。而在执行异步操作时，会启动多个线程来执行各个操作，并且他们开启的顺序以及执行的时间各不相同，具体的区别我们
C#中关于多线程、同步和异步的几点说明
zhigedali的博客
02-10 1630
多线程相关操作
Timer是同步的
donghaima的专栏
11-27 751
Timer是同步的，也就说这样private void timer1_Tick(object sender, EventArgs e){   lock (this)   {      i++;    }      } 和这样private void timer1_Tick(object sender, EventArgs e){   i++;}的功能是相同的。 
c# 多线程学习路线
最新发布
02-24
学习C#多线程的路线可以按照以下步骤进行： 1. 先了解基本概念：开始学习之前，建议先了解多线程的基本概念和原理，包括线程、进程、并发、同步等相关概念。 2. 学习线程的创建和启动：学习如何在C#中创建和启动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

望天hous

你的鼓励是我最大动力~谢谢啦！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值