C#异步编程之数据并行及任务并行

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

基于Parallel.ForEach的数据并行使用

1.数据非并行

var items = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
DateTime t1 = DateTime.Now;
foreach (var item in items)
{
    Console.WriteLine("数据非并行输出:{0}", item);
}

2.数据并行,只要使用Parallel.ForEach

Parallel.ForEach(items, item => Console.WriteLine("数据并行输出：{0}", item));

3.非并行与并行耗时对比

var items = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
DateTime t1 = DateTime.Now;
foreach (var item in items)
{
    Console.WriteLine("数据非并行输出:{0}", item);
}
DateTime t2 = DateTime.Now;
TimeSpan t3 = t2 - t1;
Console.WriteLine("非数据并行输出耗费时间：毫秒:{0},微秒:{1}", t3.Milliseconds, t3.Microseconds);

t1 = DateTime.Now;
Parallel.ForEach(items, item => Console.WriteLine("数据并行输出：{0}", item));
t2 = DateTime.Now;
t3 = t2 - t1;
Console.WriteLine("数据并行输出耗费时间：毫秒:{0},微秒:{1}", t3.Milliseconds, t3.Microseconds);

 基于Parallel.For的数据并行使用

1. Parallel.For返回一个ParallelLoopResult结构

public struct ParallelLoopResult
{
	internal bool _completed;

	internal long? _lowestBreakIteration;

	public bool IsCompleted => _completed;

	public long? LowestBreakIteration => _lowestBreakIteration;
}

下面的result类型为 ParallelLoopResult结构

var result = Parallel.For(1, 101, (i, state) => {
});

 完整示例:

//Parallel.For返回一个ParallelLoopResult结构
var result = Parallel.For(1, 101, (i, state) => {
    
    int delay;
    lock (rnd);
    delay = rnd.Next(1, 1001);//随机生成1到1001之间随机数
    Thread.Sleep(delay);//随机休眠线程

    //循环调用了退出方法Break
    if (state.ShouldExitCurrentIteration)
    {
        if (state.LowestBreakIteration < i)
        {
            Console.WriteLine("循环调用了退出方法Break()");
            return;
        }
    }

    if (i == breakIndex)
    {
        Console.WriteLine($"随机数与索引相同,将退出循环,索引: {i}");
        state.Break();//退出循环
    }

    Console.WriteLine($"完成循环遍历,当前循环索引: {i}");

});

if (result.LowestBreakIteration.HasValue)
    Console.WriteLine($"\nLowest Break Iteration: {result.LowestBreakIteration}");
else
    Console.WriteLine($"\nNo lowest break iteration.");

基于Parallel.ForEach的数据并行操作数据并使用局部变量

//初始化数组
int[] input = { 4, 1, 6, 2, 9, 5, 10, 3 };
int sum = 0;

try
{
    Parallel.ForEach(
            input,                          //要并行遍历的集合
            () => 0,                        //线程本地初始化
            //n当前遍历元素,loopState:并行状态对象,localSum局部变量
            (n, loopState, localSum) =>     //匿名函数,localSum会初始化为0
            {
                localSum += n;//累加元素
                //输出当前线程ID,元素值,与累加后的元素值
                Console.WriteLine("Thread={0}, n={1}, localSum={2}", Thread.CurrentThread.ManagedThreadId, n, localSum);
                //返回累加后的值
                return localSum;
            },
            //任务动作,传入线程本地变量localSum
            (localSum) => Interlocked.Add(ref sum, localSum) //多线程元子性操作共享变量
    );
    //输出并行操作后的结果
    Console.WriteLine("\nSum={0}", sum);
}
catch (AggregateException e) //捕获线程操作异常
{
    Console.WriteLine("并行操作数据异常\n{0}", e.Message.ToString());
}

基于Parallel.Invoke的任务并行操作

//静态函数实现,供并行任务使用
static void BasicAction()
{
    Console.WriteLine("静态方法BasicAction, Thread={0}", Thread.CurrentThread.ManagedThreadId);
}
try
{
    Parallel.Invoke(
        BasicAction,    // 任务1 - 静态方法
        () =>           // 任务2 - lambda表达式
        {
            Console.WriteLine($"lambda表达式, Thread:{Thread.CurrentThread.ManagedThreadId}");
        },
        delegate ()     // 任务3 - 肉联委托
        {
            Console.WriteLine($"肉联委托, Thread:{Thread.CurrentThread.ManagedThreadId}");
        }
    );
}
catch (AggregateException e) //捕获任务并行异常
{
    Console.WriteLine($"抛出异常:{e.InnerException.ToString()}");
}

基于Parallel.ForEachAsync的异常并行操作,异步方法要添加await关键字

await Parallel.ForEachAsync(Enumerable.Range(1, 100),
    async (_, _) => {
        await Task.Delay(1000);
    });

在任务中使用数据并行:

//创建任务线程
Task _t = new Task(() => {
    Console.WriteLine($"这个是任务子线程");
    Parallel.ForEach(items, (item, state) =>{
        Console.WriteLine($"{item},{state}");
    });
});
Console.WriteLine($"任务线程:{_t.Id}");
_t.Start();//开始任务

任务的运行及等待

Thread.CurrentThread.Name = "主线程";
//创建任务并运行
Task taskA = Task.Run(
    () => {
        Thread.CurrentThread.Name = "任务子线程";
        Console.WriteLine($"当前线程名:-> '{Thread.CurrentThread.Name}',线程ID:{Thread.CurrentThread.ManagedThreadId}");
        Console.WriteLine("这个是在任务中输出的信息"); //使用匿名函数
    }
    );
Console.WriteLine($"当前线程名: '{Thread.CurrentThread.Name}',线程ID:{Thread.CurrentThread.ManagedThreadId}");
taskA.Wait();//等待任务完成

任务分离:

//分离任务
var outer = Task.Factory.StartNew(() =>
{
    Console.WriteLine("任务开始...");

    var child = Task.Factory.StartNew(() =>
    {
        Thread.SpinWait(5000000);
        Console.WriteLine("任务分离成功.");
    });
});
outer.Wait();
Console.WriteLine("任务结束.");

任务阻塞:

//阻塞任务
Task[] tasks = new Task[3]
{
    Task.Factory.StartNew(() => Console.WriteLine("任务1.")),
    Task.Factory.StartNew(() => Console.WriteLine("任务2.")),
    Task.Factory.StartNew(() => Console.WriteLine("任务3."))
};
Task.WaitAll(tasks);//阻塞直接所有任务完成

多任务使用:

//多任务使用
Task[] taskArray = new Task[10];
for (int i = 0; i < taskArray.Length; i++)
{
    //使用任务工厂启动任务
    taskArray[i] = Task.Factory.StartNew((Object obj) =>
    {
        CustomData data = obj as CustomData;//实例化类对象
        if (data == null) return;

        data.ThreadNum = Thread.CurrentThread.ManagedThreadId;//赋值当前线程ID
    },
    new CustomData() { Name = i, CreationTime = DateTime.Now.Ticks });
};
Task.WaitAll(taskArray);
//遍历任务
foreach (var task in taskArray)
{
    var data = task.AsyncState as CustomData;
    if (data != null)
        Console.WriteLine("任务 #{0} 已创建于 {1}, 在线程 #{2}.",
                          data.Name, data.CreationTime, data.ThreadNum);
}

class CustomData
{
    public long CreationTime;
    public int Name;
    public int ThreadNum;
}

完整Demo:

// See https://aka.ms/new-console-template for more information

using System;
using System.Diagnostics;

var items = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
DateTime t1 = DateTime.Now;
foreach (var item in items)
{
    Console.WriteLine("数据非并行输出:{0}", item);
}
DateTime t2 = DateTime.Now;
TimeSpan t3 = t2 - t1;
Console.WriteLine("非数据并行输出耗费时间：毫秒:{0},微秒:{1}", t3.Milliseconds, t3.Microseconds);

t1 = DateTime.Now;
Parallel.ForEach(items, item => Console.WriteLine("数据并行输出：{0}", item));
t2 = DateTime.Now;
t3 = t2 - t1;
Console.WriteLine("数据并行输出耗费时间：毫秒:{0},微秒:{1}", t3.Milliseconds, t3.Microseconds);


var rnd = new Random();
Console.WriteLine("开始遍历...");
int breakIndex = rnd.Next(1, 11);
Console.WriteLine($"Will call Break at iteration {breakIndex}\n");

//Parallel.For返回一个ParallelLoopResult结构
var result = Parallel.For(1, 101, (i, state) => {
    
    int delay;
    lock (rnd);
    delay = rnd.Next(1, 1001);//随机生成1到1001之间随机数
    Thread.Sleep(delay);//随机休眠线程

    //循环调用了退出方法Break
    if (state.ShouldExitCurrentIteration)
    {
        if (state.LowestBreakIteration < i)
        {
            Console.WriteLine("循环调用了退出方法Break()");
            return;
        }
    }

    if (i == breakIndex)
    {
        Console.WriteLine($"随机数与索引相同,将退出循环,索引: {i}");
        state.Break();//退出循环
    }

    Console.WriteLine($"完成循环遍历,当前循环索引: {i}");

});

if (result.LowestBreakIteration.HasValue)
    Console.WriteLine($"\nLowest Break Iteration: {result.LowestBreakIteration}");
else
    Console.WriteLine($"\nNo lowest break iteration.");

//初始化数组
int[] input = { 4, 1, 6, 2, 9, 5, 10, 3 };
int sum = 0;

try
{
    Parallel.ForEach(
            input,                          //要并行遍历的集合
            () => 0,                        //线程本地初始化
            //n当前遍历元素,loopState:并行状态对象,localSum局部变量
            (n, loopState, localSum) =>     //匿名函数,localSum会初始化为0
            {
                localSum += n;//累加元素
                //输出当前线程ID,元素值,与累加后的元素值
                Console.WriteLine("Thread={0}, n={1}, localSum={2}", Thread.CurrentThread.ManagedThreadId, n, localSum);
                //返回累加后的值
                return localSum;
            },
            //任务动作,传入线程本地变量localSum
            (localSum) => Interlocked.Add(ref sum, localSum) //多线程元子性操作共享变量
    );
    //输出并行操作后的结果
    Console.WriteLine("\nSum={0}", sum);
}
catch (AggregateException e) //捕获线程操作异常
{
    Console.WriteLine("并行操作数据异常\n{0}", e.Message.ToString());
}


//静态函数实现,供并行任务使用
static void BasicAction()
{
    Console.WriteLine("静态方法BasicAction, Thread={0}", Thread.CurrentThread.ManagedThreadId);
}
try
{
    Parallel.Invoke(
        BasicAction,    // 任务1 - 静态方法
        () =>           // 任务2 - lambda表达式
        {
            Console.WriteLine($"lambda表达式, Thread:{Thread.CurrentThread.ManagedThreadId}");
        },
        delegate ()     // 任务3 - 肉联委托
        {
            Console.WriteLine($"肉联委托, Thread:{Thread.CurrentThread.ManagedThreadId}");
        }
    );
}
catch (AggregateException e) //捕获任务并行异常
{
    Console.WriteLine($"抛出异常:{e.InnerException.ToString()}");
}



var watch = Stopwatch.StartNew();
Console.WriteLine(watch.ElapsedMilliseconds);
Console.WriteLine($"当前机器的CPU数量:{Environment.ProcessorCount}");
watch.Restart();

//使用异步并行方法
await Parallel.ForEachAsync(Enumerable.Range(1, 100),
    async (_, _) => {
        await Task.Delay(1000);
    });
watch.Stop();
Console.WriteLine($"花费时间:{watch.ElapsedMilliseconds}");
watch.Restart();

Thread.CurrentThread.Name = "主线程";
//创建任务线程
Task _t = new Task(() => {
    Console.WriteLine($"这个是任务子线程");
    Parallel.ForEach(items, (item, state) =>{
        Console.WriteLine($"{item},{state}");
    });
});
Console.WriteLine($"任务线程:{_t.Id}");
_t.Start();//开始任务

Thread.CurrentThread.Name = "主线程";
//创建任务并运行
Task taskA = Task.Run(
    () => {
        Thread.CurrentThread.Name = "任务子线程";
        Console.WriteLine($"当前线程名:-> '{Thread.CurrentThread.Name}',线程ID:{Thread.CurrentThread.ManagedThreadId}");
        Console.WriteLine("这个是在任务中输出的信息"); //使用匿名函数
    }
    );
Console.WriteLine($"当前线程名: '{Thread.CurrentThread.Name}',线程ID:{Thread.CurrentThread.ManagedThreadId}");
taskA.Wait();//等待任务完成

//分离任务
var outer = Task.Factory.StartNew(() =>
{
    Console.WriteLine("任务开始...");

    var child = Task.Factory.StartNew(() =>
    {
        Thread.SpinWait(5000000);
        Console.WriteLine("任务分离成功.");
    });
});
outer.Wait();
Console.WriteLine("任务结束.");

//阻塞任务
Task[] tasks = new Task[3]
{
    Task.Factory.StartNew(() => Console.WriteLine("任务1.")),
    Task.Factory.StartNew(() => Console.WriteLine("任务2.")),
    Task.Factory.StartNew(() => Console.WriteLine("任务3."))
};
Task.WaitAll(tasks);//阻塞直接所有任务完成

//多任务使用
Task[] taskArray = new Task[10];
for (int i = 0; i < taskArray.Length; i++)
{
    //使用任务工厂启动任务
    taskArray[i] = Task.Factory.StartNew((Object obj) =>
    {
        CustomData data = obj as CustomData;//实例化类对象
        if (data == null) return;

        data.ThreadNum = Thread.CurrentThread.ManagedThreadId;//赋值当前线程ID
    },
    new CustomData() { Name = i, CreationTime = DateTime.Now.Ticks });
};
Task.WaitAll(taskArray);
//遍历任务
foreach (var task in taskArray)
{
    var data = task.AsyncState as CustomData;
    if (data != null)
        Console.WriteLine("任务 #{0} 已创建于 {1}, 在线程 #{2}.",
                          data.Name, data.CreationTime, data.ThreadNum);
}

class CustomData
{
    public long CreationTime;
    public int Name;
    public int ThreadNum;
}

编程汇
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
来谈谈C#多线程开发：并行，并发与异步编程
谁为拨动染血的时空苍穹
12-09 850
1、前言 现代程序开发过程中不可避免会使用到多线程相关的技术，之所以要使用多线程，主要原因或目的大致有以下几个： 1、 业务特性决定程序就是多任务的，比如，一边采集数据、一边分析数据、同时还要实时显示数据； 2、 在执行一个较长时间的任务时，不能阻塞UI界面响应，必须通过后台线程处理； 3、 在执行批量计算密集型任务时，采用多线程技术可以提高运行效率。 传统使用的多线程技术有： Thread & ThreadPool Timer BackgroundWorker 目前，这些技术都不
谈谈C#多线程开发：并行、并发与异步编程
slw20010213的博客
12-17 5401
概述 现代程序开发过程中不可避免会使用到多线程相关的技术，之所以要使用多线程，主要原因或目的大致有以下几个： 1、 业务特性决定程序就是多任务的，比如，一边采集数据、一边分析数据、同时还要实时显示数据； 2、 在执行一个较长时间的任务时，不能阻塞UI界面响应，必须通过后台线程处理； 3、 在执行批量计算密集型任务时，采用多线程技术可以提高运行效率。 传统使用的多线程技术有： Thread & ThreadPool Timer BackgroundWorker 目前，这些技术都不再..
C#任务并行库 (TPL)之Parallel.For和Parallel.ForEach循环、处理并行循环中的异常
qq_35320456的博客
04-27 1516
在实际应用中，使用Parallel.For和Parallel.ForEach时需要考虑任务的复杂性、数据依赖性和同步问题，以确保并行循环能带来性能上的提升。同时，监控并行循环的执行情况和资源使用情况也是保证应用程序高效稳定运行的重要方面。
C#中的异步和并行编程模式
VivianCharlotte的博客
04-23 488
在C#编程中，异步和并行编程是提高应用程序性能和响应能力的关键技术。本文将深入探讨C#中的异步和并行编程模式，包括它们的基本概念、应用场景以及如何在实际开发中运用。C#中的异步和并行编程模式是提高程序性能和响应能力的重要工具。例如，可以在异步方法中启动多个并行任务，以充分利用多核处理器的能力，并在所有任务完成后异步返回结果。使用TAP模式，开发者可以写出像同步代码一样简洁易读的异步代码，而编译器和运行时将负责底层复杂的异步操作。EAP是早期的异步编程模型，它使用事件来表示异步操作的完成。
C# 异步编程 并行编程
sudazf的专栏
09-28 9385
目录 异步编程 1. Thread 2. Task 3.async + await 并行编程 Parallel 本篇简单记录一下异步编程和并行编程，并以下图一个 Demo 来演示,源码地址我会公布在文章结尾。 异步编程 个人觉得，异步无非就是不影响某个线程的情况下，在另外的线程里执行任务的过程。异步编程即多线程编程。C# 里多线程编程写法有很多种，这里记录三种。 ...
C#异步编程模型：Task并行与async/await深入剖析
java专栏
04-22 769
C#提供了基于Task并行库（TPL）的Task异步模型，以及async/await语法糖，极大地简化了异步编程的复杂性。通过本篇深入剖析，您应已全面理解C#中的Task并行与async/await异步编程模型，掌握了如何利用这些机制编写高效、非阻塞性的异步代码。结合文中提供的代码示例与注释，您可以轻松地将异步编程应用于实际项目中，并根据需要进行更深入的学习与优化。以上各部分已包含丰富的代码示例，并附有详细注释，阐述了Task并行、async/await关键字的使用以及异步编程的最佳实践。
c#异步编程基础
weixin_42710036的博客
11-25 699
c#异步编程基础
C# 异步编程模式详解
qq_35320456的博客
04-22 1382
C# 异步编程模式是一种强大的编程范式，它允许开发者在处理耗时操作时保持应用程序的响应性。通过 async 和 await 关键字，以及各种异步编程模式和框架，C# 提供了丰富的工具来简化异步编程的实现和维护。在实际应用中，异步编程可以显著提高应用程序的性能和用户体验，特别是在处理 I/O 密集型任务时。因此，掌握 C# 异步编程模式对于现代软件开发来说是非常有价值的。
【C#】并行编程实战：异步编程详解
cyf649669121的博客
07-20 277
本章将从介绍同步代码和异步代码之间的区别开始，然后讨论何时适合使用异步代码，以及何时应避免异步代码。最后我们将讨论并行编程中的新功能以解决异步代码复杂性的帮助。 本章相当于阶段性总结，新东西并不多。
C#异步编程详解
08-31
本文主要聚焦于Task、Async和Await这三个核心概念，它们是C# 5.0及更高版本中异步编程的核心工具。 **什么是异步？** 异步编程是一种编程模式，它允许程序在等待某个操作完成时不会阻塞当前线程，而是继续执行其他...
C#异步并行编程示例
09-28
2. **Task并行库（TPL）**: C#引入了`Task`类，作为线程管理的抽象，简化了异步编程。`Task`代表一个异步操作，它封装了工作逻辑并负责调度执行。与线程相比，`Task`更轻量级，更容易管理，也支持更好的资源调度。...
c#并行任务多种优化方案分享(异步委托)
09-04
进一步优化，C#引入了Task类和async/await关键字，提供了更为强大的异步编程支持。我们可以使用 `Task.Run()` 创建并启动异步任务，然后在需要等待时使用 `await` 关键字： ```csharp async Task Main(string[] ...
C#并行编程-Task
02-23
TPL引入新的基于任务的编程模型，通过这种编程模型可以发挥多核的功效，提升应用程序的性能，不需要编写底层复杂且重量级的线程代码。但需要注意：任务并不是线程（任务运行的时候需要使用线程，但并不是说任务取代...
C#编程总结（六）详解异步编程
09-01
【C#异步编程详解】 在C#编程中，异步编程是一种重要的技术，它允许程序在执行长时间任务时保持响应性，不阻塞主线程。本文将深入探讨异步编程的概念、区别、应用场景以及实际应用示例。 1、什么是异步？ 异步...
C# 多线程Paralle使用
qq_44967213的博客
07-26 466
在C#中，Parallel类是 System.Threading.Tasks 命名空间下的一个静态类，它提供了并行执行循环和操作的简便方法。通过使用Parallel类，可以简化多线程编程，提高应用程序执行并行任务的能力。Parallel类主要用于并行执行for和foreach循环。Parallel类包含几个静态方法，如等，这些方法能够自动将迭代分配给多个线程，以实现并行执行。
C#、Net6、WebApi报表方案
最新发布
六六的小帅的博客
07-26 791
大家可能有疑问，为什么字体路径还有一个“1”，看下图，我们使用的是“宋体”（simsun.ttc）,看文件类型是Collection，这说明这个字体文件其中包括多款字体，所以用“1”表示用的字体集合中的某款。解决方案：使用路径“C:\\windows\\fonts\\simsun.ttc,1”使用Docx库编辑word模板，将编辑好的word模板转换成pdf，提供用户下载。需要使用Adobe软件编辑pdf表单，Adobe软件需要付费使用。发送消息留言，可以分享大家完整工程代码。这应该解答了大家心中的疑惑。
C#从Socket里获取IP地址和端口号
代码笔记
07-23 238
属性来获取连接的远程IP地址和端口号。以下是一个简单的示例代码，展示了如何从一个已连接的。这段代码将输出连接的远程IP地址和端口号。，以获取或创建一个有效的。
C#并行编程高级教程：任务并行与数据并行解析
1. **基于任务的程序设计**：任务并行是.NET Framework 4中的一种主要并行编程模型，它允许开发者通过Task类创建和管理异步操作。理解硬件线程和软件线程的区别是基础，软件线程由操作系统调度，而硬件线程直接对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

编程汇

有你的鼓励，我会更加努力。

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

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

打赏作者

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

抵扣说明：

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

余额充值