c#多线程同步执行

已于 2023-10-07 22:24:37 修改
阅读量4.7k 收藏 19
点赞数
分类专栏： # 基础知识 文章标签： 经验分享
于 2022-08-05 01:02:18 首次发布
分享的越多，得到的越多。 记录的越多，忘记的越少。----故里2130
本文链接：https://blog.csdn.net/u012563853/article/details/126168926
版权

对于多线程同步执行，可能听起来比较拗口，但是它的作用在某些业务下，有非常的大作用，分别进行阐述。

同步

同步就是按照顺序1234这样进行下去，有顺序，有规律的进行着。

多线程

多线程对于单线程来说的，单线程，就是开启一个线程进行工作，多线程则是，开启多个线程进行多个工作，并且没有顺序，没有规律性。

多线程同步，则是，既有同步和多线程的特点，即开启多个线程进行工作的同时，还要按照顺序和规律执行。

其实，解决多线性同步的问题，有很多种，比如使用lock锁等等方法。本节介绍使用async/await的方法来实现他的功能。

1.建立一个winform程序，可以模拟界面处理数据

2.使用同步的方法

对变量a增加1，其中 Thread.Sleep(1000)可以表示，这个业务处理的时间，然后连续增加5次。

代码

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

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        int a = 0;
        public Form1()
        {
            InitializeComponent();
        }
        private  void button1_Click(object sender, EventArgs e)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            A();
            //Task.Delay(3000);
            //B();
            //Task.Delay(3000);
            //await  C();
            stopwatch.Stop();
            label1.Text = a.ToString();
            label2.Text = "耗时：" + stopwatch.ElapsedMilliseconds;

            //Thread.Sleep(10000);
        }
        /// <summary>
        /// 单线程，同步有顺序
        /// </summary>
        public void A()
        {
            a++;
            Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);
        }
        /// <summary>
        /// 多线程，并行，没有顺序
        /// </summary>
        public void B()
        {

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });


            //List<Task> tasks = new List<Task>();


            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //Task.WaitAll(tasks.ToArray());
        }

        /// <summary>
        /// 多线程，并行，有顺序
        /// </summary>
        /// <returns></returns>
        public async Task C()
        {
            Task task = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task;
            Task task1 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task1;

            Task task2 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task2;

            Task task3 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task3;

            Task task4 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task4;
        }


    }
}

效果

耗时5036，按照顺序执行，并且界面是卡死状态。

3.使用多线程的方法

因为变化太快了，所以增加了延迟

多线程，还可以使用B()中屏蔽的方法

代码

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

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        int a = 0;
        public Form1()
        {
            InitializeComponent();
        }
        private  void button1_Click(object sender, EventArgs e)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            //A();
            Task.Delay(3000);
            B();
            Task.Delay(3000);
            //await  C();
            stopwatch.Stop();
            label1.Text = a.ToString();
            label2.Text = "耗时：" + stopwatch.ElapsedMilliseconds;

            //Thread.Sleep(10000);
        }
        /// <summary>
        /// 单线程，同步有顺序
        /// </summary>
        public void A()
        {
            a++;
            Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);
        }
        /// <summary>
        /// 多线程，并行，没有顺序
        /// </summary>
        public void B()
        {
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });


            //List<Task> tasks = new List<Task>();


            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //Task.WaitAll(tasks.ToArray());
        }

        /// <summary>
        /// 多线程，并行，有顺序
        /// </summary>
        /// <returns></returns>
        public async Task C()
        {
            Task task = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task;
            Task task1 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task1;

            Task task2 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task2;

            Task task3 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task3;

            Task task4 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task4;
        }


    }
}

效果 

耗时29，可以看到没有按照顺序进行，但是界面是可以移动的

4. 多线程同步

这段代码就阐述了，即开启多个线程进行工作的同时，还按照顺序和规律执行。

代码

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

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        int a = 0;
        public Form1()
        {
            InitializeComponent();
        }
        private async void button1_Click(object sender, EventArgs e)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            //A();
            //Task.Delay(3000);
            //B();
            //Task.Delay(3000);
            await  C();
            stopwatch.Stop();
            label1.Text = a.ToString();
            label2.Text = "耗时：" + stopwatch.ElapsedMilliseconds;

            //Thread.Sleep(10000);
        }
        /// <summary>
        /// 单线程，同步有顺序
        /// </summary>
        public void A()
        {
            a++;
            Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);

            a++; Console.WriteLine(a);
            Thread.Sleep(1000);
        }
        /// <summary>
        /// 多线程，并行，没有顺序
        /// </summary>
        public void B()
        {
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });

            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });
            Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(10000);
            });


            //List<Task> tasks = new List<Task>();


            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //tasks.Add(Task.Run(() =>
            //{
            //    a++;
            //    Console.WriteLine(a);
            //    Thread.Sleep(1000);
            //}));

            //Task.WaitAll(tasks.ToArray());
        }

        /// <summary>
        /// 多线程，并行，有顺序
        /// </summary>
        /// <returns></returns>
        public async Task C()
        {
            Task task = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task;
            Task task1 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task1;

            Task task2 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task2;

            Task task3 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task3;

            Task task4 = Task.Run(() =>
            {
                a++;
                Console.WriteLine(a);
                Thread.Sleep(1000);
            });
            await task4;
        }


    }
}

 效果

耗时5052，并且是按照顺序执行的，而且界面还可以拖动，正是我们需要的。 

拓展async/await

在C()方法中，其实是遇到await后，代码则是返回task.run上面去了，然后从上到下再执行，执行到第二方法，又返回task.run上面去了，然后再从上到下执行，以此类推，所以和同步执行的时间基本上一样的。

来源：c#多线程同步执行_c# 如何实现一个同步执行多个方法的方法_故里2130的博客-CSDN博客

故里2130
关注
  • 0
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
夜光带你走进C#语言 中级版本（17）
夜光的博客
08-07 223
夜光序言： 距离大概就是指：你知道我没睡，我也知道你没睡，看着彼此更新的动态，却不能说上一句话。不要踮着脚尖去爱一个人，重心不稳，撑不了太久。真正的幸福只有从容的心才能遇到。 正文：java架构中也经常用到~~ C# 多线程 线程 被定义为程序的执行路径。 每个线程都定义了一个独特的控制流。 ...
C#多线程——多线程访问共同的代码或者对象
ssharet的博客
04-13 2360
多线程对共同资源的访问，往往会造成数据的混乱和不可预料的结果，因此一般需要加锁访问进行互斥访问。 所谓“互斥访问”是指，一段代码或者公共变量，在一个时刻只允许一个线程去访问，其他的线程需要等待，直到改线程处理完毕并通知下一个等待的线程去处理。 1、可以用“Lock”来提供代码的互斥访问： [csharp] view plain copy lo
C#中同步的几种方法
weixin_48083386的博客
06-04 777
但ManualResetEvent，调用set()，切换到终止模式，可以释放当前所有的waitone()，需要手动调用reset()才能切换到非终止模式。当initialState=fasle，处于non-signaled 模式(非终止状态)，调用waitone() 会等待信号阻塞当前线程(可以在多个线程中调用，同时阻塞多个线程)，直到调用set()发送信号释放线程(调用一次，只能释放一个线程)，一般使用这种方式；运行结果如下，线程1，2，3首先获取信号量锁，线程4，5，6在等待，直到1，2，3释放，
计算机中 什么是同步执行和异步执行？
Dontla的博客
12-08 5273
1 当您同步执行某项任务时，您将等待它完成，然后再转到另一项任务。当您异步执行某项任务时，您可以在它完成之前转移到另一个任务。 也就是说，在计算机的上下文中，这转化为在另一个“线程”上执行一个进程或任务。线程是作为工作单元存在的一系列命令(代码块)。操作系统可以管理多个线程，并在切换到另一个线程之前为线程分配一块(“片”)处理器时间，以使它能够完成一些工作。在其核心(请原谅双关语)，一个处理器可以...
C# 简单的多线程和使用异步方式调用同步方法
meng_xiaoxiao的博客
09-30 1120
查看MSDN看到Thread类有4个构造函数 有两个主要参数：ThreadStart和ParameterizedThreadStart； 查看MSDN可以看出： 1、ThreadStart是一个无参没有返回值的委托类型； 2、ParameterizedThreadStart是带有一个object类型参数，没有返回值的委托类型； 如下图： 使用实例源码： class P...
创建多个线程调用同一个函数的问题
bwc85719279的博客
05-29 486
创建多个线程，调用同一个函数，该函数内不能存在静态变量或全局变量，会影响线程之间对该变量的调用。
C#多线程简述（二）
苒橪
08-09 646
前面说过，每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是几个线程同时执行一个函数，导致数据的混乱，产生不可预料的结果，因此我们必须避免这种情况的发生。 C#提供了一个关键字lock，它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。在C#中，关键字lock定义如下：
C#多线程及同步示例简析
01-20
 线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的...
C#多线程读写sqlite
05-25
标题"**C#多线程读写sqlite**"涉及的主要知识点包括： 1. **多线程编程**：C#中的`System.Threading`命名空间提供了丰富的类和方法来创建和管理线程，如`Thread`类、`Task`类以及`ThreadPool`。通过多线程，程序...
c# window服务多线程实例
08-10
而多线程技术则是现代计算机编程中的核心概念，它允许程序同时执行多个独立的任务，提高了系统的效率和响应性。将多线程应用到Windows服务中，可以实现服务的并发处理能力，提高服务的性能。 创建C# Windows服务的...
详解C#多线程之线程同步
08-31
C#中的线程同步是多线程编程中的关键概念，旨在解决多个线程并发访问共享资源时可能出现的数据不一致性和竞态条件问题。线程同步的实现方式多种多样，包括基元构造和混合构造。 首先，基元构造分为用户模式和内核...
winform 线程同步源码
11-26
winform 线程同步源码! 很值得下载看看!资源免费,大家分享!!
C #中几个线程同步对象的使用方法
咖喱开发点滴
09-02 934
 在编写多线程程序时无可避免会遇到线程的同步问题。什么是线程的同步呢？ 　　举个例子：如果在一个公司里面有一个变量记录某人T的工资count=100，有两个主管A和B（即工作线程）在早一些时候拿了这个变量的值回去 ，过了一段时间A主管将T的工资加了5块，并存回count变量，而B主管将T的工资减去3块，并存回count变量。好了，本来T君可以得到102块的工资的，现在就变成98块了。这就是线程
代码的同步执行和异步执行
qq_59076775的博客
07-14 1345
js单线程
c#:线程同步
匆匆那年
01-05 2517
在C#里面用于实现线程同步的常用类有如下几类： 1、Mutex类（互斥器），Monitor类，lock方法  2、ManualResetEvent类，AutoResetEvent类（这两个都是由EventWaitHandle类派生出来的）  3、ReaderWriterLock类 分析如下： 1、ManualResetEvent类: ManualResetEvent 允许线程通过发信号
StringBuilder对象的常用方法 c#1614651638
pyhui的技术博客
03-02 188
StringBuilder对象的常用方法 c#1614651638 演练 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace stringbuilder演练 { class Program { static void Main(string[] args) {
C# 线程同步的几种方法
qq_43360872的博客
08-19 6363
在正常开发过程中总会遇到多个线程同时访问一个对象，抢占资源等问题，那么具体什么是线程同步的问题？ 下面举个例子： 我们吃饭用手机点菜的时候，多个人同时点菜，在最后结账的时候，如果大家都争着买单，那如果没有同步信息，就会造成多个人都买单成功。这就是线程同步的问题之一。 下面介绍几种线程同步的方法： 1、锁 Mutex、Monitor、lock Mutex: 互斥锁是一个互斥的同步对象，意味着同一时间有且仅有一个线程可以获取它,互斥锁可适用于一个共享资源每次只能被一个线程访问的情况。 在 Mutex 类中，Wa
C#中的线程(二) 线程同步基础
weixin_30399055的博客
06-18 161
1.同步要领 下面的表格列展了.NET对协调或同步线程动作的可用的工具： 简易阻止方法 构成 目的 Sleep 阻止给定的时间周期 Join 等待另一个线程完成 锁系统 构成 ...
c语言错误C1189
最新发布
06-18
抱歉，但您提到的"C1189"不是一个标准的C语言错误代码。通常，编译器错误代码是特定于特定编译器的，并且C1189并不属于常见的C语言错误列表。可能是您使用的某个非标准IDE、编译器插件或者自定义的错误标识。 在C语言中，标准的错误代码通常由编译器生成，例如GCC可能会使用类似“error: identifier ‘x’ is undefined”这样的信息。常见的C语言错误可能包括类型不匹配、未声明的变量、数组越界、空指针引用等。 如果您遇到具体的编译错误，请提供详细的错误信息，以便我能更准确地帮助您理解问题所在。如果C1189确实是您的问题，那可能需要查看相关的文档或项目设置，因为这可能是一个内部错误号或者是特定环境下的错误标识。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

故里2130

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值