C#并行编程

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

C#并行编程中的Parallel.Invoke

一、基础知识

并行编程：并行编程是指软件开发的代码，它能在同一时间执行多个计算任务，提高执行效率和性能一种编程方式，属于多线程编程范畴。所以我们在设计过程中一般会将很多任务划分成若干个互相独立子任务，这些任务不考虑互相的依赖和顺序。这样我们就可以使用很好的使用并行编程。但是我们都知道多核处理器的并行设计使用共享内存，如果没有考虑并发问题，就会有很多异常和达不到我们预期的效果。不过还好NET Framework4.0引入了Task Parallel Library（TPL）实现了基于任务设计而不用处理重复复杂的线程的并行开发框架。它支持数据并行，任务并行与流水线。核心主要是Task，但是一般简单的并行我们可以利用Parallel提供的静态类如下三个方法。

Parallel.Invoke 对给定任务实现并行开发

Parallel.For 对固定数目的任务提供循环迭代并行开发

parallel.Foreach 对固定数目的任务提供循环迭代并行开发

注意：所有的并行开发不是简单的以为只要将For或者Foreach换成Parallel.For与Parallel.Foreach这样简单。

PS：从简单的Invoke开始逐步深入探讨并行开发的主要知识点，也对自己学习过程中的积累做个总结，其中参考了博客园中的其他优秀博文

滴答的雨异步编程：轻量级线程同步基元对象

首先感谢您，在我学习并行开发过程中，您的博文对我帮助很大。

二、Parallel.Invoke在并行中的使用

首先我们来看看它的两个重载方法：

public static void Invoke(params Action[] actions);
public static void Invoke(ParallelOptions parallelOptions, params Action[] actions);

Invoke主要接受params的委托actions，比如我们要同时执行三个任务，我们可以这样利用

方式一
Parallel.Invoke(() => Task1(), () => Task2(), () => Task3());
方式二
Parallel.Invoke(Task1, Task2, Task3);
方式三
Parallel.Invoke(
                () =>
                {
                    Task1();
                },
               Task2,
                delegate () { Task3(); console.write('do someting!');});

这样Invoke就简单实现了Task1，Task2，Task3的并行开发。下面我们用实例来说明他们的执行规则。以及两个重载方法的使用。

三、Demo

1、 Demo 1：

public class ParallelInvoke
{
/// <summary>
/// Invoke方式一 action
/// </summary>
public void Client1()
{
Stopwatch stopWatch = new Stopwatch(); Console.WriteLine("主线程：{0}线程ID ： {1}；开始", "Client1", Thread.CurrentThread.ManagedThreadId);
stopWatch.Start();
Parallel.Invoke(() => Task1("task1"), () => Task2("task2"), () => Task3("task3"));
stopWatch.Stop();
Console.WriteLine("主线程：{0}线程ID ： {1}；结束,共用时{2}ms", "Client1", Thread.CurrentThread.ManagedThreadId, stopWatch.ElapsedMilliseconds);
} private void Task1(string data)
{
Thread.Sleep(5000);
Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
} private void Task2(string data)
{
Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
} private void Task3(string data)
{
Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
}
｝

执行运行后结果：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAY0AAAB2CAIAAAC751joAAALvklEQVR4nO2cW5bkOAhEc/+r8s5mPro7j0tAEGBZflTcL6csAUIQdrnnzOc/IYS4N5+rAxBCiATplBDi7kinhBB3RzolhLg70ikhxN35WLZtc0aJaX9GwHLS8rtR3tbgJk2ZfBXMcUb9Fi3f/rG/3nMg3iehvFVxd53mQTolCkXgVhJZVe9DeTtCafvSqbfReF5t3ivA9vOZb72419HIkS2klt0IpwO2eUbe3CSAzCxgrt9S2UyvMXE78ImCHiPrZm4NRcIEQjq7aVPFPC9vVaU7j+l+yc1G0rwvjOPBiOvBbRN1F1CEYYkdPFI6OIyzi5KXmDV5S0eWdel0v8xmh3F7MSsYcT3MKUZFU+rG46Rmb6JTYHBu3qRTHyNPrr5Lqh5PqfmZsz+vLBo6BUK1G/le21XpxnFfnZS3tJmX9ecUv4HC+Fhf9uJgPOJK+Ar4EA8xO2eww3jhI+9NSAt3M1KFp6Uu1uSN39fZDPsCPxsGo5FhfNlmxQXg3ouaJCqO7d/7SHQr8nIw1NQFHsHbYQKwnXl23txbDZ3q6Uhkx27hVJ1y8wnyL54KPkXcJFExPUKn3FLGMfOSsSBv7q0Ldarqt2oBH+6gU3ODEdfTPkVbGeTD7Ujd9HSkWvRV+/gWmHkwb1N06gzsRo5YiEaiWzdJgpgJ/8glGyyyCaThSJOTLvAIuZFoWuT61LylYZBZ7ekICMZuqmq/Wj8fuHHp1BvAbeAWGWg8YHOKTkVRbT9Jx4dbrmWwCrtekDd3X2CzgNLknqmq/VIe7DWTVXFftgrfJdaCa3YYST2esL8bobx9qcYczXcTGM18etLEKUT9JjDK2wDIAJ8cZVUIIYQQQog/uC/D+A258f78slfu6BPJlL9WhBAj7ode/NFROgU+5Ua6/03pOz6KC7EU2zzp/Gqnvawz+TdQd79A44QQDtWecSUmXUIO3o1IVTfv1WmQe2vKvXbvWr+XS/zTHy3i2ZREx/ZnWr7f7iVdLAbE39AmJnXWcmNkcQLdvQuxiPTJX10LJpxU68etlXQKvNe4djaDO9hQrmWSIW0SF9PTqf2qVK0Gs9OLfrFOgVVWgxgvfFTSKfEbAc/26FE/KJQ7nnqcBXgfcQejJdtPzWVky+49Xft0ncIbFOIUXLmJRj5epwEVYJbPAscfXX+8DIAIgR3S16CMLpE1HP/ZDLFJqsQFkDq1v8u0GTPfdV1tAywuvL5gO4NNdwtboHd7+7zWTNGpRj7TSKRT4gKqOhVNsz+/TYIFwq5ivAMjeztRVK708EGCYKL50ikh+vR0qtq9pfESOBImKnvBLE+DGYTJVUZXN8lglumFdEpcz610qvH8B3IzWIv6LZqD+9PqCxAm+xMMRrdI/bVBMjNTO1XXQsykoVPHWw64brSBXfUd2d/6+foyDn6M9GwGO8fdyyBY0WbBIIizlKJePoGpWdaEqDG0n9ucdr5djl2Qxh+BzYCbpUinXpYNIVZQag93cmohmvDuzox0SgghhBBCCCHW0/hrrvFXzMv+8Im+3IFtviwDQizF/TCMv+xKp8C/MES6/02pPqILUcY2Tzq/2mkv60z+DdTdL9A4IYRDtWdciUmXkIN3I1LVzXt1GuTemnKv3bvW7+US//RHi3g2JdGx/ZmW77d7SReLAfE3tIlJnbXcGFmcQHfvQiwiffJX14IJJ9X6cWslnQLvNa6dzeAONpRrmWRIm8TF9HRqvypVq8Hs9KI/T6fwtChvJRUrRSWdEr8R8GyPHvWDQrnjqcdZgPcRdzBasv3UXDdIoBEgjGEOty3fI47hVIY6WeNUiM8H/hUWNWraJ7jPTypxHH90/fEy0N4442tQRhfs5UKdAlsTYgWkTu3vMm3GzHddV9sAzCcbbCP+IAUS486J7PNaM0WnGvlMI5FOiQuo6lQ0zf78NgkWCLuK8Q6M7O1EUQ36wviNZMj1axdKp4To09Op0ipepxrgSJioIgHq6cJw7RrfPICpdjxTkE6J67mVTjWe/0BuBmtRv0VzUtly7ZOqBwajW6T+2iCZmamdqmshZtLQqeMtB1w32sCu+o7sb/18fRkHP4H0gPnRXgbBshPSQeC3lKJZOvWJNy7ECoYWtbjz7XLsgjT+CGwG3CxFOvWybAixglJ7uJNTC9GEd3dmpFNCCCGEEEIIsZ7GX3ONv2Je9odP9OUObPNlGRBiKe6HYfxlVzoF/oUh0v1vSvURXYgytnnS+dVOe1ln8m+g7n6BxgkhHKo940pMuoQcvCfkq9Mg98BIeteq27US/4JHi3g2JdGx/cm8SVmb96l4HL/bn0CbmNR9uJxXle48rvIrxF/SJ391LZhgNW4Kx62lFtKXHWBnM7iDDeVaJhlX+RXiLz2d2q9K1WowO73KF+sUGLQaVPJC2m8bbCOdElcCnu3Ro35QKHc89TiLKMj9LWbJ9lNzU4H4eHuP1u7ncNuinLoTTuIqv0L8aM7o1jCY1ivo1UajkqQiEs10dYpxwUzDurkFYC930KnzzlEIBKlT+7tMmzHzXdfVNgDzB2tYX7Cdwaa7hS3Qu719Xmum6NQsWdlvdopBIWqk/UAutD/Tyj5PpyLXkb5gvyVxifL5aJ2q+hViMj2dKq3idaoBjoSJyl6kLphgBmFyldHVzchpQ6fOQDolLuBWOtV4/gO5se9NeGEUajTo2o9Uj7cc3SL11wbJzEztlPwKMZmGTh1vOeC60Ql21Xdkf8t9f9n/dKVnWGLn2L0MgmUnpIMgzlKKevk825QQZYb2s7jz7XLsgjT+CGwG3CxFOvWybAixglJ7uJNTC9GEd3dmpFNCCCGEEEIIcRXkHybRFyuwXH/yfJS3Lr1PDaVpvIU1J6JzT2ASBL6sRyX1/Uj8mz8eK289HqFT7gG1D+v3HO5Z8EXjHhLo1XejvPUAumBHeNoBkPGkP3Ewv+RwWRqHunmvAFvxPyyK7h7fQmq5WqbtqKKRM/LmJgFkZgGz/EbbIXc3MQBsEE8DP6MqHX7i/TYysL4kZoKjBz1GZqqU4pTo+EFIZzet63pN3vDIyrqc5RfYIc22vVtpwGLR/mnrwbrARQKqKLqFC+8BMBlJD8mdD85jVrRMVBPBudpfr8lbOrKsNKf4rW7WXXW82Mi9lPxuRqd6Tsmo+PHHwEQfFQ1zKhNpH96CAJji+8zOW2S/bbDNXL9DV/MSMCUS0kI7jPN06ltd5PiTKGUElMswZ1Z4USTkBBCq3cj32q5KNx4VB7n808obdupOOImJfg8m4XgkpIWS32r9MNUSjUSRDHUehcTU6grcKKPImDRFKcbuepH3JoBDHX7aMyMDuCRv/L7OZjOFHv3k7fSWHM9A4yhLP/dHXJqPo3LNpu6Gi6vqJwf3XtQkOCmlPfN1nE4jS8qOpGecBmA78+y8ubcadcbnn7Fjt1A6X5s3O2j3iGlsBPzs+d28GvjE9YBDwkGWroeLRroWUU3Q/laUPnfP+LyTKLNgUheuU1tVOGacDX7mlLy5t/i1OJ6DtA2mO7IjQ/sN2+FLi4QJIw3SXuM4mSS4oYLxKAB3s9fTjsam2006PuwjTtOfYJycSdrHt8DMg3lLR64qNbuRKaaikf34kNLzKJWKPfQj1iIj+JYbg1t7jJfVMKHYPgENFtkE6TvS5KQLPEJuBBxqtOXz8paGQWb1oI5Yd3ZTVfv7vPGpxmHwwTCHkk5zk2DrgVl+vCqAzeGC3PsF4A27aQWNB2yC9JXS4UYV1QGoDzuOf0bRWhcL8ubuC2wWUJrcM0XajxKOrQ1LNnP6pWDI+Jmoop+8iyj+6JSjW1vAZ5eiaMIFROGCEN1EuGaHkdTjCfu7Ecrbl1LMUZai4nTnuxaYePhbwO8WvAZiy0882eeRnqJwUd5SGCWacjdN/qBE7RiOzxdCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghCrzmf70mhHgt0ikhxN2RTgkh7o50Sghxd6RTQgghhBBCCCGEEEIIIUTI/9adLG5H/hA8AAAAAElFTkSuQmCC" alt="" />

我们看到Invoke 执行Task三个方法主要有以下几个特点：

1、没有固定的顺序，每个Task可能是不同的线程去执行，也可能是相同的；

2、主线程必须等Invoke中的所有方法执行完成后返回才继续向下执行；这样对我们以后设计并行的时候，要考虑每个Task任务尽可能差不多，如果相差很大，比如一个时间非常长，其他都比较短，这样一个线程可能会影响整个任务的性能。这点非常重要

3、这个非常简单就实现了并行，不用我们考虑线程问题。主要Framework已经为我们控制好线程池的问题。

ps：如果其中有一个异常怎么办？带做这个问题修改了增加了一个Task4.

2、 Demo2

public class ParallelInvoke
{
/// <summary>
/// Invoke方式一 action
/// </summary>
public void Client1()
{
Stopwatch stopWatch = new Stopwatch(); Console.WriteLine("主线程：{0}线程ID ： {1}；开始", "Client1", Thread.CurrentThread.ManagedThreadId);
stopWatch.Start(); try
{
Parallel.Invoke(() => Task1("task1"), () => Task2("task2"), () => Task3("task3"), delegate () { throw new Exception("我这里发送了异常"); });
}
catch (AggregateException ae)
{
foreach (var ex in ae.InnerExceptions)
Console.WriteLine(ex.Message);
} stopWatch.Stop();
Console.WriteLine("主线程：{0}线程ID ： {1}；结束,共用时{2}ms", "Client1", Thread.CurrentThread.ManagedThreadId, stopWatch.ElapsedMilliseconds);
}
｝

主要看 delegate() { throw new Exception("我这里发送了异常");} 增加了这个委托Task3. 然后我们看结果：

aaarticlea/png;base64,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" alt="" />

这里我们发现即使有异常程序也会完成执行，而且不会影响其他Task的执行。

3、demo3 重载方法ParallelOptions 的使用。

理解ParallelOptions建议大家异步编程：轻量级线程同步基元对象讲的非常详细。

主要理解两个参数：

CancellationToken 控制线程的取消
MaxDegreeOfParallelism 设置最大的线程数，有时候可能会跑遍所有的内核，为了提高其他应用程序的稳定性，就要限制参与的内核

下面从代码上看效果如何？

public class ParallelInvoke
{
// 定义CancellationTokenSource 控制取消
readonly CancellationTokenSource _cts = new CancellationTokenSource(); /// <summary>
/// Invoke方式一 action
/// </summary>
public void Client1()
{
Console.WriteLine("主线程：{0}线程ID ： {1}；开始{2}", "Client3", Thread.CurrentThread.ManagedThreadId, DateTime.Now); var po = new ParallelOptions
{
CancellationToken = _cts.Token, // 控制线程取消
MaxDegreeOfParallelism = 3 // 设置最大的线程数3，仔细观察线程ID变化
}; Parallel.Invoke(po, () => Task1("task1"), ()=>Task5(po), Task6); Console.WriteLine("主线程：{0}线程ID ： {1}；结束{2}", "Client3", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
} private void Task1(string data)
{
Thread.Sleep(5000);
Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
}

// 打印数字
private void Task5(ParallelOptions po)
{
Console.WriteLine("进入Task5线程ID ： {0}", Thread.CurrentThread.ManagedThreadId);
int i = 0;
while (i < 100)
{
// 判断是否已经取消
if (po.CancellationToken.IsCancellationRequested)
{
Console.WriteLine("已经被取消。");
return;
} Thread.Sleep(100);
Console.Write(i + " ");
Interlocked.Increment(ref i);
} } /// <summary>
/// 10秒后取消
/// </summary>
private void Task6()
{
Console.WriteLine("进入取消任务，Task6线程ID ： {0}", Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(1000 * 10);
_cts.Cancel();
Console.WriteLine("发起取消请求...........");
}
｝

执行结果：

aaarticlea/png;base64,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" alt="" />

从程序结果我们看到以下特点：

1、程序在执行过程中线程数码不超过3个。

2、CancellationTokenSource/CancellationToken控制任务的取消。

四、总结

Parallel.Invoke 的使用过程中我们要注意以下特点：

1、没有特定的顺序，Invoke中的方法全部执行完才返回，但是即使有异常在执行过程中也同样会完成，他只是一个很简单的并行处理方法，特点就是简单，不需要我们考虑线程的问题。

2、如果在设计Invoke中有个需要很长时间，这样会影响整个Invoke的效率和性能，这个我们在设计每个task时候必须去考虑的。

3、Invoke 参数是委托方法。

4、当然Invoke在每次调用都有开销的，不一定并行一定比串行好，要根据实际情况，内核环境多次测试调优才可以。

5、异常处理比较复杂。