并发编程概述和并行编程（Parallel Framework）

任务（task）

异步编程（async&await）

并发编程概述

前言

说实话，在我软件开发的头两年几乎不考虑并发编程，请求与响应把业务逻辑尽快完成一个星期的任务能两天完成绝不拖三天（剩下时间各种浪），根本不会考虑性能问题（能接受范围内）。但随着工作内容的变化，一些问题，它的解决方案已经让我避不开并发编程这一块知识点了。为了一劳永逸，此系列与并发编程有关的系列文章诞生，希望对各有有所帮助。

基础术语

同步（synchronization）：关于协调线程或进程之间的活动，并确保被多个线程或进程访问的数据一直有效，同步允许线程和进程一致地操作。
并发（concurrency）：同时做多间事情，是关于程序的各个方面的合作和串联工作，以实现目标。
进程（Process）：一个具有一定独立功能的程序关于某个数据集合的一次运行活动，是系统进行资源分配和调度运行的基本单位，当一个程序开始运行时，它在系统中奖开启一个或多个进程，一个进程又有多个线程组成。
线程（thread）：代表程序中的单个执行逻辑流程，是一个独立处理的执行路径，是轻量级的进程。
多线程（multithreading）：多个线程来执行程序。并发的一种形式，但不是唯一的方式。
并行处理：把正在执行的大量的任务分割成小块，分配给多个同时运行的线程。多线程的一种。
异步编程：并发的一种形式，采用future模式或回调（callback）机制，以避免产生不必要的线程。

异步编程

异步编程并不一定要用多线程去实现，多线程只是其中一种实现手段。在.Net中，新版funture类型有Task和Task。
老式异步编程API中采用回调或事件（event）。异步编程的核心理念是异步操作。

异步操作：启动了的操作将会在一段时间后完成。这个操作执行时，不会阻塞原来的线程。启动了这个操作的线程，可以继续执行其他任务。当操作完成时，会通知它的future或调用回调函数，以便让程序指导操作已经结束。
响应式编程：一种声明式的编程模式，程序在该模式中对事件做出响应，区别于异步编程是因为它是基于异步事件（asynchronous
evnt）。并发编程的一种形式。

I/O密集与计算密集

I/O密集（I/O-bound）：如果一个操作将大部分时间用于等待一个条件的产生，那么它就被成为I/O密集操作。
计算密集（compute-bound）：如果一个操作将大部分时间用于执行CPU密集操作，那么它被称为计算密集操作。

并发编程

优秀软件的关键特征就是具有并发性，程序在同一时间做着更多的事情，而不是过去我们看到的一种单请求单响应。智能化、高用户体验的程序已经离不并发编程。

并行编程（Parallel Framework）

前言

并行编程：通过编码方式利用多核或多处理器称为并行编程，多线程概念的一个子集。

并行处理：把正在执行的大量的任务分割成小块，分配给多个同时运行的线程。多线程的一种。

并行编程分为如下几个结构：

1.并行的LINQ或PLINQ

2.Parallel类

3.任务并行结构

4.并发集合

5.SpinLock和SpinWait

这些是.NET 4.0引入的功能，一般被称为PFX（Parallel Framework，并行框架）。

Parallel类和任务并行结构称为TPL（Task Parallel Library，任务并行库）。

并行框架（PFX）

1.并行框架基础

当前CPU技术达到瓶颈，而制造商将关注重点转移到提高内核技术上，而标准单线程代码并不会因此而自动提高运行速度。
利用多核提升程序性能通常需要对计算密集型代码进行一些处理：
1.将代码划分成块。
2.通过多线程并行执行这些代码块。
3.结果变为可用后，以线程安全和高性能的方式整合这些结果。
传统多线程结构虽然实现功能，但难度颇高且不方便，特别是划分和整理的步骤（本质问题是：多线程同时使用相同数据时，出于线程安全考虑进行锁定的常用策略会引发大量竞争）。
而并行框架（Parallel Framework）专门用于在这些应用场景中提供帮助。

2.并行框架组成

PFX：高层由两个数据并行API组成：PLINQ或Parallel类。底层包含任务并行类和一组另外的结构为并行编程提供帮助。
在这里插入图片描述

基础并行语言集成查询（PLINQ）

语言集成查询（Language Integrated Query,LINQ）提供了一个简捷的语法来查询数据集合。而这种由一个线程顺序处理数据集合的方式我们称为顺序查询（sequential query）。

并行语言集成查询（Parallel LINQ）是LINQ的并行版。它将顺序查询转换为并行查询，在内部使用任务，将集合中数据项的处理工作分散到多个CPU上，以并发处理多个数据项。

PLINQ将自动并行化本地的LINQ查询，System.Linq.ParallelEnumerable类（它定义在System.Core.dll中，需要引用System.Linq）公开了所有标准LINQ操作符的并行版本。这些所有方法是依据System.Linq.ParallelQuery扩展而来。

1.LINQ to PLINQ
要让LINQ查询调用并行版本，必须将自己的顺序查询（基于IEnumerable或IEnumerable）转换成并行查询（基于ParallelQuery或ParallelQuery）,使用ParallelEnumerable的AsParallel方法实现,如示例：
1.PLINQ执行模型
在这里插入图片描述

Parallel类

Parallel类是对线程的一个很好的抽象。该类位于System.Threading.Tasks命名空间中，提供了数据和任务并行性。

PFX通过Parallel类中的三个静态方法，提供了一种基本形式的结构化并行机制：

1.Parallel.Invoke

Parallel.Invoke：用于并行执行一组委托，示例如下：

任务并行

对于任务并行的内容，请戳任务（Task）和异步编程（async&await）。

2.Parallel.For

Parallel.For：执行C# for循环的并行化等价循环，示例如下：

class ParallelDemo
    {
        static void Main(string[] args)
        {
            //顺序循环
            {
                for (int i = 0; i < 10; i++)
                {
                    Test(i);
                }
            }
            Console.WriteLine("并行化for开始");
            //顺序执行转换为并行化
            {
                Parallel.For(0, 10, i => Test(i));
            }
            //顺序执行转换为并行化（更简单的方式）
            {
                Parallel.For(0, 10, Test);
            }
            Console.ReadKey();
        }
        static void Test(int i)
        {
            Console.WriteLine($"当前线程Id：{Thread.CurrentThread.ManagedThreadId},输出结果为：{i}");
        }
    }

3.Parallel.ForEach

Parallel.ForEach：执行C# foreach循环的并行化等价循环，示例如下：

static void Main(string[] args)
        {
            顺序循环
            //{
            //    for (int i = 0; i < 10; i++)
            //    {
            //        Test(i);
            //    }
            //}
            //Console.WriteLine("并行化for开始");
            顺序执行转换为并行化
            //{
            //    Parallel.For(0, 10, i => Test(i));
            //}
            顺序执行转换为并行化（更简单的方式）
            //{
            //    Parallel.For(0, 10, Test);
            //}

            string[] data = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
            //顺序循环
            {
                foreach (string num in data)
                {
                    Test(num);
                }
            }
            Console.WriteLine("并行化foreach开始");
            //顺序执行转换为并行化
            {
                Parallel.ForEach(data, num => Test(num));
            }
            Console.ReadKey();
            Console.ReadKey();
        }
        static void Test(int i)
        {
            Console.WriteLine($"当前线程Id：{Thread.CurrentThread.ManagedThreadId},输出结果为：{i}");
        }
        static void Test(string i)
        {
            Console.WriteLine($"当前线程Id：{Thread.CurrentThread.ManagedThreadId},输出结果为：{i}");
        }

在这里插入图片描述

4.索引&跳出（ParallelLoopState）

有时迭代索引很有用处，但是切忌不可像顺序循环的用法使用共享变量（循环内i++）的方式使用，因为共享变量值在并行上下文中是线程不安全的。

同样的，因为并行For或ForEach中的循环体是一个委托，所以无法使用break语句提前退出循环，必须调用ParallelLoopState对象上的Break或Stop方法。

以ForEach为例，ForEach重载的其中之一如下，它包含Acton的其中有三个参数（TSourec=子元素，ParallelLoopState=并行循环状态，long=索引）：

 public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource, ParallelLoopState, long> body)
``

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class ParallelDemo
    {
        static void Main(string[] args)
        {
            顺序循环
            //{
            //    for (int i = 0; i < 10; i++)
            //    {
            //        Test(i);
            //    }
            //}
            //Console.WriteLine("并行化for开始");
            顺序执行转换为并行化
            //{
            //    Parallel.For(0, 10, i => Test(i));
            //}
            顺序执行转换为并行化（更简单的方式）
            //{
            //    Parallel.For(0, 10, Test);
            //}

            string[] data = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
            //顺序循环
            //{
            //    foreach (string num in data)
            //    {
            //        Test(num);
            //    }
            //}
            Console.WriteLine("并行化foreach开始");
            //顺序执行转换为并行化
            {
                Parallel.ForEach(data, (num , state, i)=>
                {
                    Console.WriteLine($"当前索引为:{i},状态为:{state}");
                    Test(num);
                    if (num == "six")
                        state.Break();
                });

               
            }
            Console.ReadKey();
            Console.ReadKey();
        }
        static void Test(int i)
        {
            Console.WriteLine($"当前线程Id：{Thread.CurrentThread.ManagedThreadId},输出结果为：{i}");
        }
        static void Test(string i)
        {
            Console.WriteLine($"当前线程Id：{Thread.CurrentThread.ManagedThreadId},输出结果为：{i}");
        }
    }
}