C#异步线程总结

最新推荐文章于 2024-04-22 21:04:46 发布
最新推荐文章于 2024-04-22 21:04:46 发布
阅读量2.5k 收藏 22
点赞数 6
分类专栏： C#语言 文章标签： c# 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41703489/article/details/128236557
版权

一. Thread

C#的所有异步多线程都是对Thread对象的封装。

  1. Thread的使用：
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread = new Thread(ThreadInvoke);
            thread.Start();
        }

        private void ThreadInvoke()
        {
            Console.WriteLine("Thread is running.");
        }
    }

运行结果：
在这里插入图片描述
2. 也可以使用Lambda表达式代替执行方法，运行结果与上面例子一样。

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

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread = new Thread(() =>
            {
                Console.WriteLine("Thread is running.");
            });
            thread.Start();
        }
    }
  1. 使用ThreadStart封装执行方法，运行结果与上面一样。
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            ThreadStart threadStart = new ThreadStart(ThreadInvoke);
            Thread thread = new Thread(threadStart);
            thread.Start();
        }

        private void ThreadInvoke()
        {
            Console.WriteLine("Thread is running.");
        }
    }

4.IsBackground属性，可以设置该线程是否和主线程一起关闭；设置为false，当主线程关闭后，该线程还会运行，可以使用此特性进行一些关闭工作的资源释放。

二. ThreadPool

  1. 线程池使用场景更多，不用自己创建线程，从线程池中取线程使用。
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            ThreadPool.QueueUserWorkItem(ThreadPoolInvoke, "This is First.");
            // 线程池中只要有可用的线程，立刻调用
            ThreadPool.QueueUserWorkItem((o) =>
            {
                Console.WriteLine("线程ID：" + Thread.CurrentThread.ManagedThreadId);
                Console.WriteLine(o.ToString());
            }, "This is Second.");
        }

        private void ThreadPoolInvoke(object o)
        {
            Console.WriteLine("线程ID：" + Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(o.ToString());
        }
    }

运行结果：
在这里插入图片描述
2. 线程池通过SetMaxThreads和GetMaxThreads设定和获取线程中最大的工作线程数量

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

        private void button1_Click(object sender, EventArgs e)
        {
            ThreadPool.QueueUserWorkItem(ThreadPoolInvoke, "This is First.");

            ThreadPool.SetMinThreads(20, 16);
            ThreadPool.SetMaxThreads(20, 16);
            ThreadPool.GetMaxThreads(out int mW, out int mC);
            Console.WriteLine(mW + "----" + mC);
        }

        private void ThreadPoolInvoke(object o)
        {
            Console.WriteLine("线程ID：" + Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(o.ToString());
        }
    }

运行结果：
在这里插入图片描述
3.异步等待
主线程等待异步线程的执行

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

        private ManualResetEvent manualResetEvent = new ManualResetEvent(false);

        private void button1_Click(object sender, EventArgs e)
        {
            
            ThreadPool.QueueUserWorkItem(ThreadPoolInvoke, null);

            // 阻止主线程继续执行，将主线程设置为等待线程，等待异步线程的执行情况。
            // 如果异步线程中，不设置manualResetEvent.Set();则该线程一直等待中，主线程陷入卡死状态。
            manualResetEvent.WaitOne();
            Console.WriteLine("World.");
        }

        private void ThreadPoolInvoke(object o)
        {
            Console.WriteLine("Hello ");

            // 允许等待线程WaitOne后的代码可以继续执行；如果没有这句代码，主线程一直因为WaitOne而等待。
            this.manualResetEvent.Set();

        }
    }

运行结果：
在这里插入图片描述

三. Task

Task的异步线程调用

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

        private ManualResetEvent manualResetEvent = new ManualResetEvent(false);

        private void button1_Click(object sender, EventArgs e)
        {
            // 直接调用
            Task.Run(TaskInvoke);

            // 利用匿名委托调用
            Task.Run(delegate ()
            {
                Console.WriteLine("This is anonymous delegate invoke.");
            });

            // 利用Lambda表达式调用
            Task.Run(() =>
            {
                Console.WriteLine("This is noraml invoke.");
            });

            // 常规的调用方法
            Task task = new Task(TaskInvoke);
            task.Start();

            // 工厂模式调用
            TaskFactory taskFactory = new TaskFactory();
            taskFactory.StartNew(TaskInvoke);
            taskFactory.StartNew(() => { });
            taskFactory.StartNew(delegate () { });
        }

        private void TaskInvoke()
        {
            Console.WriteLine("This is delegate invoke.");
        }
    }

四. Task线程间的同步

1.如果不控制同步，则主线的后续代码执行顺序并不固定：

        private void button1_Click(object sender, EventArgs e)
        {
            List<Task> tasks = new List<Task>();
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));

            Console.WriteLine("OK");
        }

        private void TaskInvoke()
        {
            Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
        }

两次运行结果：
在这里插入图片描述
在这里插入图片描述
2. 利用WhenAll方法和ContinueWith方法，所有子线程执行完毕后，才会执行ContinueWith方法中的委托

        private void button1_Click(object sender, EventArgs e)
        {
            List<Task> tasks = new List<Task>();
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));

            Task.WhenAll(tasks).ContinueWith((o) => { Console.WriteLine("OK"); });
            
        }

        private void TaskInvoke()
        {
            Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
        }
    }
  1. 先阻塞主线程，利用WaitAny，任何一个子线程执行完成，主线程都可以执行，所以每次主线程接着开始运行的地方都会不一样。
        private void button1_Click(object sender, EventArgs e)
        {
            List<Task> tasks = new List<Task>();
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));
            tasks.Add(Task.Run(() => { this.TaskInvoke(); }));

            Task.WaitAny(tasks.ToArray());
            Console.WriteLine("OK");
        }

        private void TaskInvoke()
        {
            Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
        }

运行结果：

在这里插入图片描述
在这里插入图片描述
4. 如果需要阻塞主线程，等待所有子线程都运行完毕，再运行主线程，使用WaitAll方法。用法和WaitAny类似。其功能和await类似，但await不会阻塞主线程，因为await之后的代码会放到一个子线程里面去执行，所以主线程不会等待阻塞。

五. Parallel

  1. Parallel直接调用
        private void button1_Click(object sender, EventArgs e)
        {
            Parallel.Invoke(
                () => { Console.WriteLine(Thread.CurrentThread.ManagedThreadId); },
                () => { Console.WriteLine(Thread.CurrentThread.ManagedThreadId); },
                () => { Console.WriteLine(Thread.CurrentThread.ManagedThreadId); });
        }
  1. For并发
        private void button1_Click(object sender, EventArgs e)
        {
            ParallelOptions parallelOptions = new ParallelOptions();
            //允许的最大并发数量
            parallelOptions.MaxDegreeOfParallelism = 5;
            // 一共产生10个并发，0是起始值，10是最大计数值，i是每次的计数
            // 虽然是10个并发，但是按设置每次并发5个
            Parallel.For(0, 10, parallelOptions, (i) =>
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
            });
        }

3.ForEach并发

        private void button1_Click(object sender, EventArgs e)
        {
            ParallelOptions parallelOptions = new ParallelOptions();
            //允许的最大并发数量
            parallelOptions.MaxDegreeOfParallelism = 5;

            // string[]数组作为参数，每个并发都会把string[]数组里面的一个成员传入线程执行
            Parallel.ForEach(new string[] { "go", "run" }, parallelOptions, c =>
            {
                Console.WriteLine(c);
            });
        }

运行结果：
在这里插入图片描述

嘉州子
关注
  • 6
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 异步编程
qq_33218137的博客
06-03 4905
C#异步编程
C#异步多线程快速入门
Mekeater的博客
05-10 1345
C#异步多线程快速入门 前言：
C# 异步编程模式详解
最新发布
qq_35320456的博客
04-22 1012
C# 异步编程模式是一种强大的编程范式，它允许开发者在处理耗时操作时保持应用程序的响应性。通过 async 和 await 关键字，以及各种异步编程模式和框架，C# 提供了丰富的工具来简化异步编程的实现和维护。在实际应用中，异步编程可以显著提高应用程序的性能和用户体验，特别是在处理 I/O 密集型任务时。因此，掌握 C# 异步编程模式对于现代软件开发来说是非常有价值的。
C# 异步操作汇总
gzylongxingtianxia的专栏
03-04 1841
使用 Task 或 Task 的主要优点是，它们提供了一种更灵活的方式来执行异步操作，因为它们允许您在异步操作完成之前执行其他代码。Task 和 Task 的区别在于 Task 可以返回一个值，而 Task 不可以。async和await是.NET Framework 4.5引入的一种新的异步编程模型，它基于Task和Task，使异步编程更加简单和直观。Task和Task方式是.NET Framework 4.0引入的一种新的异步编程模型，它更加灵活和直观，可以方便地管理和控制异步操作的状态和结果。
C# 中的多线程和异步编程
知识在于理解,运用在于总结,高阶在于巩固!
10-16 6265
C# 支持通过多线程并行执行代码，线程有其独立的执行路径，能够与其它线程同时执行。
C#基础--异步编程
不求上进的码农的博客
09-26 2300
BeginXXX方法接受其同步方法的所有输入参数， EndXXX方法使用同步方法的所有输出参数，并按照同步方法的返回类型来返回结果。使用异步模式时， BeginXXX方法还定义了一个AsyncCallback参数，用于接受在异步方法执行完成后调用的委托。在有些情况下，如果一个异步方法依赖另一个异步方法的结果， await关键字就非常有用。例如，某方法可以有一个路径，其中数据 是从一个具有异步API的服务中检索出来的。基于任务的异步模式指定，在异步方法名后加上Async后缀， 并返回一个任务。
C#多线程与异步的区别详解
12-31
C#多线程与异步的区别详解 随着拥有多个硬线程 CPU（超线程、双核）的普及，多线程和异步操作等并发程序设计方法也受到了更多的关注和讨论。本文主要是想与各位高手一同探讨一下如何使用并发来最大化程序的性能。 ...
c#Winform异步线程刷新UI
12-27
使用开发工具为VS2013;.net：4.0 多线程异步刷新ui界面，实时获取任务进度并进行反馈。
C#.net同步异步SOCKET通讯和多线程总结
10-06
C#.net同步异步SOCKET通讯和多线程总结 C#.net同步异步SOCKET通讯和多线程总结是指在C#.net环境下实现的同步异步套接字通信和多线程编程的总结。套接字（Socket）是tcp/ip网络协议接口，内部定义了许多的函数和例程...
C#停止线程的方法
09-03
总结起来，C#中停止线程的最佳实践是使用协作式取消机制，如`CancellationTokenSource`和`CancellationToken`，而不是直接终止线程。这样可以避免潜在的并发问题，确保程序的稳定性和数据一致性。在实际应用中，还...
解析C#多线程编程中异步多线程的实现及线程池的使用
09-02
总结来说，C#中的多线程编程包括创建线程、异步编程、线程池的使用以及线程同步和并发控制等多个方面。了解并熟练掌握这些概念和技术，有助于编写高效、稳定的并发应用程序。在实际开发中，应根据任务特性和系统资源...
C#用委托BeginInvoke做异步线程
08-26
今天小编就为大家分享一篇关于C#用委托BeginInvoke做异步线程，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C# 多线程异步执行
06-20
使用委托事件模拟多线程下载网络图片，即同时发送多个网络请求下载图片。 也可应用于其他异步多线程执行事件。
c#多线程线程池和异步编程
03-11
我们将在这里进一步讨论一些.NET类,以及他们在多线程编程中扮演的角色和怎么编程。它们是: 　　System.Threading.ThreadPool 类 　　System.Threading.Timer 类 　　如果线程的数目并不是很多,而且你想控制每个线程的细节诸如线程的优先级等,使用Thread是比较合适的;但是如果有大量的线程,考虑使用线程池应该更好一些,它提供了高效的线程管理机制来处理多任务。 对于定期的执行任务Timer类是合适的;使用代表是异步方法调用的首选。
C#异步编程由浅入深
weixin_68436326的博客
04-01 438
一、什么算异步？广义来讲，两个工作流能同时进行就算异步，例如，CPU与外设之间的工作流就是异步的。在面向服务的系统中，各个子系统之间通信一般都是异步的，例如，订单系统与支付系统之间的通信是异步的，又如，在现实生活中，你去馆子吃饭，工作流是这样的，点菜->下单->做你的事->上菜->吃饭，这个也是异步的，具体来讲你和厨师之间是异步的，异步是如此重要，因外它代表者高效率（两者或...
c# 异步编程详解
gxuliang601的博客
03-13 9199
要使用异步，就是用委托进行处理，如果委托对象在调用列表中只有一个方法，它就可以异步执行这个方法。委托类有两个方法，叫做BeginInvoke和EndInvoke，它们是用来异步执行使用。BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。
C#中异步多线程的常见用法
chinaherolts2008的博客
02-25 494
先来看几个基本概念（纯属个人见解，可能不准确）： 进程：程序运行时，占用的全部运行资源的总和。 线程：线程是隶属于操作系统管理的，也可以有自己的计算资源，是程序执行流的最小单位。任何的操作都是由线程来完成的。 每个线程都在操作系统的进程内执行，而操作系统进程提供了程序运行的独立环境。 多线程：多核cpu协同工作，多个执行流同时运行，是用资源换时间。（单核cpu，不存在所谓的多线程）。 单线程应用：在进程的独立环境中只跑一个线程，所以该线程拥有独立权。 多线程应用：单个进程中会跑多个线程，它们会共享当前的执行
C#多线程和异步
CoffeMilk的博客
07-12 1714
C#多线程和异步的示例项目工程下载 一、什么是异步 　　同步和异步主要用于修饰方法。 ①同步：当一个方法被调用时，调用者需要等待该方法执行完毕并返回才能继续执行，我们称这个方法是同步方法； ②异步：当一个方法被调用时立即返回，并获取一个线程执行该方法内部的业务，调用者不用等待该方法执行完毕，我们称这个方法为异步方法。 　　异步的好处在于非阻塞(调用线程不会暂停执行去等待子线程完成)，因此我们把一些不需要立即使用结果、较耗时的任务设为异步执行，可以提高程序的运行效率。net4.0在ThreadPoo
C#异步线程（一）异步委托
YongYu_IT的专栏
03-26 1122
一、关于委托的回顾 委托其实相当于C++里面的函数指针。官方描述是：委托是方法的类型安全的引用。 1、普通委托 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp
c# 异步线程打开文件
11-16
以下是在C#中使用异步线程打开文件的示例代码： ```csharp using System; using System.IO;using System.Threading.Tasks; class Program { static async Task Main(string[] args) { Console.WriteLine("主线程开始"); // 异步打开文件 using (FileStream stream = new FileStream("example.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)) { byte[] buffer = new byte[stream.Length]; await stream.ReadAsync(buffer, 0, buffer.Length); Console.WriteLine("文件内容："); Console.WriteLine(System.Text.Encoding.Default.GetString(buffer)); } Console.WriteLine("主线程结束"); Console.Read(); } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值