并发和并行之间有什么区别？

示例被赞赏。

并发是指两个或多个任务可以在重叠的时间段内启动，运行和完成。并不一定意味着它们都将同时运行。例如，单核计算机上的多任务处理。

并行是指任务实际上在同一时间（例如，在多核处理器上）运行。

引用Sun的《多线程编程指南》：

• 并发：至少有两个线程在进行时存在的条件。并行性的一种更通用的形式，可以包括时间切片作为虚拟并行性的一种形式。

• 并行性：当至少两个线程同时执行时出现的条件。

为什么混乱存在

之所以存在混乱，是因为这两个词的字典含义几乎相同：

• 并发：存在，同时发生或同时发生（dictionary.com）
• 并行：非常相似，并且经常同时发生（merriam webster）。

但是它们在计算机科学和编程中的使用方式却大不相同。这是我的解释：

• 并发：可中断性
• 并行性：独立性

那么，以上定义是什么意思？

我将用现实世界的类比来澄清。假设您必须在一天内完成两项非常重要的任务：

1. 领护照
2. 完成演示

现在，问题是任务1要求您去一个极其官僚的政府办公室，这使您需要排队4个小时才能拿到护照。同时，您的办公室需要任务2，这是一项关键任务。两者都必须在特定的日期完成。

情况1：顺序执行

通常，您将开车去护照办公室2个小时，在排队等候4个小时，完成任务，开车回去2个小时，回家，再保持清醒5个小时，并完成演示。

情况2：并行执行

但是你很聪明。您要提前计划。您可以随身携带一台笔记本电脑，在排队等候时，您可以开始制作演示文稿。这样，回到家后，您只需要多工作1个小时而不是5个小时即可。

在这种情况下，这两项任务都是由您自己完成的。您在排队等候时中断了护照工作，并进行了演示。拨打电话时，您中断了演示任务并切换到护照任务。由于这两个任务的可中断性，因此基本上可以节省时间。

并发IMO可理解为ACID中的“隔离”属性。如果可以以任何交错的方式执行子事务，则两个数据库事务被认为是隔离的，并且最终结果与两个任务是顺序执行的相同。请记住，对于护照和出示任务，您都是唯一的execution子手。

情况3：并行执行

现在，由于您是一个聪明的家伙，您显然是个高个子，而且您有一位助手。因此，在您离开开始执行护照任务之前，请打电话给他，并告诉他准备演示文稿的初稿。您花了一整天时间完成护照任务，回来查看邮件，然后找到演示文稿草稿。他的工作做得非常扎实，您还需要2个多小时的修改才能完成工作。

既然如此，您的助手就和您一样聪明，他可以独立进行此工作，而无需不断地要求您进行澄清。因此，由于任务的独立性，它们是由两个不同的执行者同时执行的。

还在我这儿？好的...

情况4：并发但不并行

记住您的护照任务，您必须在排队等候的地方吗？由于这是您的护照，您的助手无法排队等候您。因此，护照任务具有可中断性（您可以在排队等候时将其停止，然后在呼叫您的号码时恢复它），但是没有独立性（您的助手不能替您等待）。

情况5：并行但不并行

假设政府办公室有进入房间的安全检查。在这里，您必须删除所有电子设备并将其提交给管理人员，它们只会在您完成任务后退还您的设备。

在这种情况下，护照任务既不可独立也不可中断。即使您在排队等候，您也无法做其他事情，因为您没有必要的设备。

同样，假设演示文稿具有很高的数学性质，因此您需要100％的浓度至少5个小时。即使排队携带笔记本电脑，也无法在排队等待护照任务时这样做。

在这种情况下，演示任务是独立的（您或您的助手可以投入5个小时的精力），但不能中断。

情况6：并行执行

现在，说除了分配演示文稿的助手外，您还需要携带一台笔记本电脑来完成护照任务。在排队等候时，您会看到助手已在共享卡座中创建了前10张幻灯片。您对他的工作发表了评论，并作了一些更正。稍后，当您回到家中时，无需花2个小时来完成草稿，而只需15分钟。

之所以可以这样做是因为演示文稿任务具有独立性（你们中的任何一个都可以做到）和可中断性（您可以将其停止并稍后再恢复）。因此，您同时执行了两个任务，并并行执行了演示任务。

可以说，除了过分的官僚主义之外，政府机关还处于腐败状态。因此，您可以出示您的身份证，输入身份证，开始排队等候打来您的电话号码，贿赂警卫和其他人在排队中保持您的位置，偷偷溜走，在拨打电话号码之前回来，然后继续等待你自己

在这种情况下，您可以同时并行执行护照和出示任务。您可以偷偷溜走，而您的职位由您的助手担任。你们俩都可以进行演示等等。

回到计算机科学

在计算世界中，以下是每种情况的典型示例场景：

• 情况1：中断处理。
• 情况2：当只有一个处理器时，由于I / O，所有正在执行的任务都有等待时间。
• 情况3：在我们谈论映射减少或hadoop集群时经常出现。
• 情况4：我认为情况4很少见。并发但不并行的任务很少见。但这有可能发生。例如，假设您的任务需要访问特殊的计算芯片，该芯片只能通过处理器1进行访问。因此，即使处理器2空闲并且处理器1正在执行其他任务，特殊计算任务也无法在处理器2上进行。
• 情况5：也很罕见，但不如情况4少。非并行代码可能是受互斥对象保护的关键区域。一旦启动，它必须执行到完成。但是，两个不同的关键区域可以在两个不同的处理器上同时进行。
• 情况6： IMO，关于并行或并发编程的大多数讨论基本上都是在讨论情况6。这是并行和并发执行的混合与匹配。

并发

如果您了解Rob Pike为何说并发性更好，那么您必须了解原因是。您的任务非常漫长，其中有多个等待期，您在其中等待某些外部操作，例如文件读取，网络下载。在他的演讲中，他只想说：“只要打破这个漫长的顺序任务，就可以在等待时做一些有用的事情。” 这就是为什么他谈论带有各种地鼠的不同组织的原因。

现在，Go的优势来自于使用go关键字和渠道轻松实现这一突破。此外，在运行时中还提供了出色的基础支持来调度这些goroutine。

但是从本质上讲，并发比并行性更好吗？

苹果比橘子好吗？

我喜欢Rob Pike的演讲：并发不是并行（更好！） （幻灯片） （演讲）

Rob通常会谈论Go，并且通常会通过直观的解释来解决并发与并行性问题！这是一个简短的摘要：

任务：让我们燃烧一堆过时的语言手册！一次一个！

并发：任务有许多并发分解！一个例子：

并行性：如果至少有两个地鼠同时工作或不同时工作，则先前的配置会并行发生。

补充别人的话：

并发就像让杂耍杂耍的人玩弄许多球。不管看起来如何，魔术师一次只能抓/扔一个球。并行性是多个杂耍者同时玩杂耍球。

假设您有一个具有两个线程的程序。该程序可以通过两种方式运行：

Concurrency                 Concurrency + parallelism
(Single-Core CPU)           (Multi-Core CPU)
 ___                         ___ ___
|th1|                       |th1|th2|
|   |                       |   |___|
|___|___                    |   |___
    |th2|                   |___|th2|
 ___|___|                    ___|___|
|th1|                       |th1|
|___|___                    |   |___
    |th2|                   |   |th2|

在这两种情况下，仅由于我们有多个线程在运行，我们就具有并发性。

如果我们在具有单个CPU内核的计算机上运行该程序，则操作系统将在两个线程之间切换，从而允许一次运行一个线程。

如果我们在具有多核CPU的计算机上运行该程序，那么我们将能够同时并行运行两个线程-并排运行。

并发：如果一个处理器解决了两个或多个问题。

并行性：如果一个问题由多个处理器解决。

我将尝试通过一个有趣且易于理解的示例进行解释。:)

假设一个组织组织一次国际象棋锦标赛，其中10名玩家（具有相同的国际象棋技巧）将挑战职业冠军国际象棋玩家。而且由于国际象棋是1：1的比赛，因此组织者必须以省时的方式进行10场比赛，以便他们能够尽快完成整个比赛。

希望以下场景可以轻松地描述进行这10场比赛的多种方式：

1）SERIAL（串行） -假设专业人员与每个人一个人玩，即与一个人开始和结束游戏，然后与下一个人开始下一个游戏，依此类推。换句话说，他们决定按顺序进行游戏。因此，如果一场比赛需要10分钟才能完成，那么10场比赛将需要100分钟，还要假设从一场比赛过渡到另一场比赛需要6秒，那么10场比赛将需要54秒（大约1分钟）。

因此整个活动将在101分钟内大致完成（最差方法）

2）CONCURRENT-可以说，职业选手轮到他的下一位选手，所以所有的10位选手同时比赛，但是职业选手一次没有两个人，他在自己的回合上前进了一位。现在假设职业玩家花费6秒来进行转牌，职业玩家黑白两人的过渡时间为6秒，因此回到第一位玩家的总过渡时间为1分钟（10x6sec）。因此，当他回到与事件开始的第一个人时，已经过去了2分钟（10xtime_per_turn_by_champion + 10xtransition_time = 2mins）

假设所有玩家需要45秒才能完成转弯，则根据SERIAL事件中每场比赛的10分钟进行。游戏结束前的回合数应为600 /（45 + 6）= 11回合

因此，整个事件将在11xtime_per_turn_by_player _＆_ champion + 11xtransition_time_across_10_players = 11x51 + 11x60sec = 561 + 660 = 1221sec = 20.35mins中大约完成

查看从101分钟到20.35分钟的改进（更好的方法）

3）平行 -假设组织者获得了一些额外的资金，因此决定邀请两名职业冠军球员（均具备同样的能力），并将同一10名球员（挑战者）分成两组，每组5个人，并将他们分配给两名冠军，即一名分组。现在，事件在这两组中并行进行，即至少有两名玩家（每组一名）与各自组中的两名职业玩家对战。

但是，在该组中，专业玩家一次只能带一个玩家（即按顺序），因此无需任何计算，您就可以轻松推断出整个事件将在101/2 = 50.5分钟内大致完成

查看从101分钟到50.5分钟的改进（良好的方法）

4）CONCURRENT + PARALLEL-在上述情况下，假设两个冠军玩家将与各自组中的5个玩家同时玩（读第二点），因此现在跨组的游戏是并行运行的，但在组内它们是同时运行的。

因此，一组游戏将在11xtime_per_turn_by_player _＆_ champion + 11xtransition_time_across_5_players = 11x51 + 11x30 = 600 + 330 = 930sec = 15.5分钟内完成

因此，整个活动（包括两个这样的并行运行组）将在15.5分钟内完成

查看从101分钟到15.5分钟的改进（最佳方法）

注意：在上述情况下，如果用10个相似的工作替换10个播放器，并用两个CPU内核替换两个专业播放器，则以下顺序将仍然成立：

串行>并行>并行>并行+并行

（注意：此顺序在其他情况下可能会更改，因为此顺序高度依赖于作业的相互依赖性，通信需要黑白作业和过渡开销黑白作业）

简单的例子：

并发是：“两个队列访问一台ATM机”

并行是：“两个队列和两个ATM机”

想象通过观看视频教程学习一种新的编程语言。您需要暂停视频，应用代码中所说的内容，然后继续观看。那是并发的。

现在您是一名专业程序员。您可以一边编码一边欣赏平静的音乐。那就是并行性。

正如Andrew Gerrand在GoLang博客中所说

并发就是一次处理很多事情。并行是关于一次做很多事情。

请享用。

他们解决了不同的问题。并发解决了CPU资源不足和任务繁多的问题。因此，您可以通过代码创建线程或独立的执行路径，以便在稀缺资源上共享时间。直到最近，由于CPU的可用性，并发一直是讨论的主要内容。

并行解决了以下问题：找到足够多的任务和适当的任务（可以正确拆分的任务），然后将其分配给大量的CPU资源。并行性当然一直存在，但由于多核处理器非常便宜，因此它已经走在前列。

并发性：具有共享资源潜力的多个执行流

例如：两个线程争用一个I / O端口。

平行主义：将问题分成多个相似的块。

例如：通过在文件的每半部分上运行两个进程来解析大文件。

并发编程执行有两种类型：非并行并发编程和并行并发编程（也称为并行性）。

关键区别在于，在人眼中，非并行并发中的线程似乎是同时运行的，但实际上它们并非同时运行。在非并行并发线程中，线程会快速切换，并通过时间分片轮流使用处理器。在并行处理中，有多个处理器可用，因此，多个线程可以同时在不同的处理器上运行。

参考：编程语言中的并发简介

并行是在multiple cores per CPU或上同时执行进程multiple CPUs (on a single motherboard)。

并发是指通过使用划分CPU时间（时间片）的调度算法实现并行化。流程是交错的。single core/CPU

单位：

• 一个CPU中包含1个或多个内核（几乎是所有现代处理器）
• 主板上1个或多个CPU （想想老式服务器）
• 1个应用程序是1个程序（以Chrome浏览器为例）
• 1个程序可以有1个或多个进程（认为​​每个Chrome浏览器标签都是一个进程）
• 1个进程可以有1个程序中的1个或多个线程（Chrome标签中有1个线程在播放Youtube视频，另一个线程是在注释部分生成的，另一个是用户登录信息的线程）
• 因此，一个程序可以具有1个或多个执行线程
• 1个进程是thread(s)+allocated memory resources by OS （堆，寄存器，堆栈，类内存）

并发 =>当在重叠的时间段内使用共享资源执行多个任务时（可能最大程度地利用资源）。

并行 =>当单个任务分为多个可以同时执行的简单独立子任务时。

可以将其视为服务队列，其中服务器只能服务队列中的第一个作业。

1个服务器，1个作业队列（包含5个作业）->没有并发，没有并行性（只有一个作业正在完成服务，队列中的下一个作业必须等待，直到服务的作业完成并且没有其他服务器可以服务）

1个服务器，2个或更多个不同的队列（每个队列5个作业）->并发性（由于服务器与队列中的所有第一个作业（均等或加权）共享时间），由于在任何时刻都没有并行性，因此只有一个被服务的工作。

2台或更多服务器，一个队列->并行性（同一时间完成2个作业），但没有并发（服务器未共享时间，第三个作业必须等到其中一个服务器完成）。

2个或更多服务器，2个或更多不同队列->并发和并行

换句话说，并发就是共享时间来完成一项工作，并发可能花费相同的时间来完成其工作，但至少它要尽早开始。重要的是，可以将作业切成较小的作业，从而可以进行交错。

并行是通过更多并行运行的CPU，服务器，人员等来实现的。

请记住，如果共享资源，则无法实现纯粹的并行性，但这就是并发将在最佳实践中发挥作用的地方，而这又是一项不需要该资源的工作。

我将提供一个与此处的一些流行答案有些冲突的答案。在我看来，并发是一个包含并行性的通用术语。 并发适用于不同任务或工作单元在时间上重叠的任何情况。 并行性更具体地适用于在同一物理时间评估/执行不同工作单元的情况。并行性的存在理由正在加速可以从多种物理计算资源中受益的软件。适用于并发的另一个主要概念是交互性。 互动性当可以从外部观察到任务重叠时适用。交互作用的根源在于，该软件可以响应现实世界中的实体，例如用户，网络对等方，硬件外围设备等。

并行性和交互性几乎完全是并发的独立维度。对于特定项目，开发人员可能会关心这两者，或者两者都不关心。它们趋向于混为一谈，这不仅是因为线程的可憎性提供了一个相当方便的原始函数来完成这两个任务。

有关并行性的更多细节：

并行性存在于非常小的规模（例如，处理器中的指令级并行性），中等规模（例如，多核处理器）和大规模（例如，高性能计算集群）。近年来，由于多核处理器的增长，对软件开发人员暴露更多线程级并行性的压力越来越大。并行性与依赖的概念紧密相关。依赖关系限制了并行性的实现范围；如果一项任务依赖于另一项任务，则不能并行执行两项任务（忽略推测）。

程序员可以使用许多模式和框架来表达并行性：管道，任务池，对数据结构（“并行数组”）的聚合操作。

有关交互性的更多详细信息：

进行交互的最基本，最常见的方法是使用事件（即事件循环和处理程序/回调）。对于简单的任务，事件很棒。尝试使用事件执行更复杂的任务会陷入堆栈崩溃（又名回调地狱；又名控件反转）。当您对事件感到厌倦时，您可以尝试更多奇特的事物，例如生成器，协程（aka Async / Await）或协作线程。

为了喜欢可靠的软件，如果您想要的是交互性，请不要使用线程。

守纪律

我不喜欢Rob Pike的“并发不是并行性；它更好”的口号。并发既不比并行性好也不坏。并发包括交互性，而交互性是无法以更好/更差的方式与并行性进行比较的。这就像在说“控制流胜于数据”。

在电子产品中，串行和并行代表一种静态拓扑，它决定了电路的实际行为。当没有并发时，并行是确定性的。

为了描述动态的，与时间相关的现象，我们使用顺序和并发术语。例如，可以通过一定顺序的任务（例如，食谱）获得特定结果。当我们与某人交谈时，我们会产生一系列单词。但是，实际上，许多其他过程是在同一时刻发生的，因此，它们同意某个操作的实际结果。如果很多人在同一时间讲话，那么同时进行的讲话可能会干扰我们的顺序，但是这种干扰的结果尚不清楚。并发引入不确定性。

串行/并行和顺序/并行表征是正交的。数字通信就是一个例子。在串行适配器中，数字消息沿同一条通信线（例如一根线）在时间上（即顺序地）分布。在并行适配器中，这也被划分为并行通信线路（例如，多条电线），然后在接收端进行重构。

让我们想象一个有9个孩子的游戏。如果我们将它们按链放置，首先给出一条消息，最后收到一条消息，那么我们将进行串行通信。消息由更多单词组成，由一系列通信单元组成。

I like ice-cream so much. > X > X > X > X > X > X > X > X > X > ....

这是在串行基础结构上复制的顺序过程。

现在，让我们以图像的方式将子级划分为3组。我们将词组分为三部分，将第一个部分分配给我们左侧行的子项，第二个分配给中心线的子级，依此类推。

I like ice-cream so much. > I like    > X > X > X > .... > ....
                          > ice-cream > X > X > X > ....
                          > so much   > X > X > X > ....

这是在并行基础结构上重现的顺序过程（尽管仍然部分序列化）。

在这两种情况下，假设孩子之间都存在完美的交流，则结果是预先确定的。

如果还有其他人与您同时与第一个孩子说话，那么我们将有多个并发流程。我们不知道基础架构将考虑哪个过程，因此最终结果是无法预先确定的。

并发是并行化的一般形式。例如，并行程序也可以称为并发，但是反向不是真的。

1. 可以在单个处理器（多个线程，由调度程序或线程池管理）上并发执行

2. 在单个处理器上不能并行执行，而在多个处理器上不能并行执行。（每个处理器一个进程）

3. 分布式计算也是一个相关的主题，它也可以称为并发计算，但是反向不是真的，就像并行性一样。

有关详细信息，请阅读此研究论文 并行编程的概念

我真的很喜欢另一个答案中的这种图形表示形式-我认为它比上面的许多答案更好地回答了问题

并行与并发 当两个线程并行运行时，它们都同时运行。例如，如果我们有两个线程A和B，则它们的并行执行将如下所示：

CPU 1：A ------------------------->

CPU 2：B ------------------------->

当两个线程同时运行时，它们的执行重叠。重叠可以通过以下两种方式之一发生：要么线程同时执行（即如上所述，并行执行），要么它们的执行在处理器上交织在一起，如下所示：

CPU 1：A -----------> B ----------> A -----------> B -------- ->

因此，出于我们的目的，可以将并行性视为并发的特殊情况

资料来源：这里的另一个答案

希望能有所帮助。

我非常喜欢Paul Butcher 对这个问题的回答（他是《七周内七个并发模型》的作者）：

尽管它们经常混淆，但并行性和并发性却是不同的。并发是问题域的一个方面，您的代码需要处理多个同时（或接近同时）的事件。相反，并行是解决方案领域的一个方面 –您希望通过并行处理问题的不同部分来使程序运行更快。有些方法适用于并发，有些适用于并行性，有些则适用于两者。了解您面临的问题，并为工作选择合适的工具。

并发可能涉及任务是否同时运行（它们确实可以在单独的处理器/内核中运行，但它们也可以在“滴答”中运行）。什么是重要的是，并发总是指做一件更大的一个任务。因此，基本上这是一些计算的一部分。您必须对可以同时执行的操作，不可以执行的操作以及如何进行同步保持聪明。

并行意味着您正在同时做一些事情。他们不需要成为解决一个问题的一部分。例如，您的线程可以分别解决一个问题。当然，同步的东西也适用，但是从不同的角度来看。

“并发”是当有多个事情的进展。

“平行主义”是指同时发生的事情在同时进行。

没有并行的并发示例：

• 单核上有多个线程。
• Win32消息队列中的多个消息。
• MARS连接SqlDataReader上的多个。
• 浏览器标签中有多个JavaScript 承诺。

但是请注意，并发性和并行性之间的差异通常是一个透视问题。从执行代码（可观察到的效果）的角度来看，以上示例是并行的。但是，即使在单个内核中也存在指令级并行性。有些硬件与CPU并行运行，然后在完成时中断CPU。在执行窗口过程或事件处理程序时，GPU可能正在绘制到屏幕上。当您仍在获取上一个查询的结果时，DBMS可能会遍历下一个查询的B树。浏览器在执行时可能正在布局或联网Promise.resolve()。等等...

所以你去了。世界一如既往的混乱;）

在我看来，理解这两者的最简单，最优雅的方式就是这样。并发允许执行的交错，因此可以给人以错觉并行。例如，这意味着并发系统可以与在Word中编写文档的同时运行Youtube视频。作为并发系统的底层OS使这些任务可以交错执行。因为计算机执行指令的速度如此之快，所以看起来好像一次可以做两件事。

并行是当这种事情真的存在时并行的。在上面的示例中，您可能会发现视频处理代码正在单个内核上执行，而Word应用程序正在另一个内核上运行。注意，这意味着并发程序也可以是并行的！使用线程和进程来构造您的应用程序使您的程序能够利用基础硬件，并有可能并行完成。

那么为什么不将所有事物并行化呢？一个原因是因为并发是一种构造程序的方式，并且是便于关注点分离的设计决策，而并行性通常是以性能的名义使用的。另一个是根本上无法完全并行完成某些事情。这样的一个例子是在队列的后面添加两件事-您不能同时插入两者。必须先进行某些操作，然后再进行其他操作，否则您会弄乱队列。尽管我们可以交错执行（并因此获得并发队列），但是您不能并行执行。

希望这可以帮助！

并发编程考虑的操作似乎是重叠的，并且主要与由于不确定性控制流而引起的复杂性有关。与并发程序相关的量化成本通常既是吞吐量又是延迟。并发程序通常受IO约束，但并不总是如此，例如，并发垃圾回收器完全在CPU上。并发程序的教学示例是Web搜寻器。该程序启动对网页的请求，并在下载结果可用时并发接受响应，从而累积一组已被访问的页面。控制流是不确定的，因为每次运行程序时不一定都以相同的顺序接收响应。这种特性会使调试并发程序变得非常困难。某些应用程序基本上是并发的，例如，Web服务器必须同时处理客户端连接。对于高度并发的编程，Erlang也许是最有前途的语言。

并行编程涉及为了提高吞吐量的特定目标而重叠的操作。通过确定控制流可以避免并发编程的困难。通常，程序会生成并行运行的子任务集，并且父任务仅在每个子任务完成后才继续。这使得并行程序更易于调试。并行编程的难点是针对粒度和通信等问题的性能优化。在多核环境中，后者仍然是一个问题，因为与将数据从一个缓存传输到另一个缓存相关的成本很高。密集矩阵矩阵乘法是并行编程的教学示例，可以使用Straasen'有效地解决 的分治法和并行处理子问题。对于共享内存计算机（包括多核）上的高性能并行编程，Cilk也许是最有前途的语言。

从我的答案中复制：https : //stackoverflow.com/a/3982782

并行性： 让多个线程执行相似的任务，它们在执行它们所需的数据和资源方面彼此独立。例如：Google搜寻器可以产生数千个线程，每个线程可以独立完成其任务。

并发： 当您在线程之间共享数据，共享资源时，并发就会显现出来。在事务系统中，这意味着您必须使用诸如锁，信号量等之类的技术来同步代码的关键部分。

（我很惊讶这么多年以来，这样一个基本问题未能正确，整洁地解决...）

简而言之，并发性和并行性都是计算的属性。

区别在于，这是Robert Harper的解释：

首先要了解的是并行性与并发无关。并发与程序（或其组成部分）的不确定性构成有关。并行性与具有确定性行为的程序的渐近效率有关。并发就是管理难以处理的事情：事件由于无法控制的原因而到达，我们必须对此做出回应。用户单击鼠标，即使显示需要引起注意，窗口管理器也必须响应。这种情况本质上是不确定的，但我们也采用形式在确定性环境中进行非确定性，方法是假装组件以任意顺序表示事件，并且我们必须在事件出现时对其进行响应。非确定性组合是强大的程序结构构想。另一方面，并​​行性是关于确定性计算的子计算之间的依赖性的。结果是毋庸置疑的，但是有很多方法可以实现它，有些方法比其他方法更有效。我们希望利用这些机会发挥我们的优势。

它们可以是程序中的各种正交属性。阅读此博客文章以获取其他插图。而这一篇则稍微讨论了有关编程组件（例如线程）的区别。

请注意，线程或多任务都是用于更具体目的的所有计算实现。它们可以与并行性和并发性相关，但不是必须的。因此，它们几乎不是开始解释的好方法。

另一个要点是：（物理）“时间”几乎与此处讨论的属性无关。时间只是执行测量以显示特性重要性的一种方式，但与本质相去甚远。三思而后行，“时间”在时间复杂度中的作用 -或多或少相似，即使在这种情况下，测量通常也更重要。

“并发”是在同时做任何事情。它们可以是不同的事物，也可以是同一事物。尽管缺少公认的答案，但这并不是关于“似乎同时出现”。确实是在同一时间。您需要多个CPU内核（使用一台主机内的共享内存或不同主机上的分布式内存）来运行并发代码。一个示例是同时运行的3个不同任务的管道：任务级别2必须等待任务级别1完成的单元，而任务级别3必须等待任务级别1完成的单元任务级别2。另一个例子是1个生产者与1个消费者的并发。或许多生产者和1个消费者；读者和作家；等。

“并行”在同一时间做相同的事情。它是并发的，但是它是同时发生的相同行为，并且通常是在不同数据上发生的。矩阵代数通常可以并行化，因为您需要重复运行相同的操作：例如，可以使用相同的行为（总和）在不同的列上同时计算矩阵的列总和。在可用处理器内核之间划分（拆分）列是一种常见的策略，这样您就可以接近每个处理器内核要处理的相同数量的工作（列数）。分散工作的另一种方法是任务袋，完成工作的工人可以回到经理那里，后者分发工作并动态地获得更多工作，直到一切完成为止。票务算法是另一种。

不仅数字代码可以并行化。文件经常可以并行处理。在自然语言处理应用程序中，对于数百万个文档文件中的每个文件，您可能需要计算文档中标记的数量。这是并行的，因为您要为每个文件计数令牌，这是相同的行为。

换句话说，并行是指同时执行相同的行为。同时表示相同但不一定相同的行为。并行是一种特殊的并发，其中同一件事同时发生。

例如，术语将包括原子指令，关键部分，互斥，自旋等待，信号量，监视器，障碍，消息传递，map-reduce，心跳，振铃，票务算法，线程，MPI，OpenMP。

格雷戈里·安德鲁斯（Gregory Andrews）的著作是一本顶级教科书：多线程，并行和分布式编程。

太好了，让我以一个场景来展示我的理解。假设有3个孩子，分别是：A，B，C。A和B说话，C听。对于A和B，它们是平行的：A：我是A。B：我是B。

但是对于C来说，他的大脑必须采取并发过程来收听A和B，这也许是：我是B。

简单并发意味着要运行多个任务（不必并行执行）。例如，假设我们在任何时候都有3个任务：一个以上可能正在运行，或者所有可能同时运行。

并行性意味着它们实际上是并行运行的。因此，在这种情况下，所有这三个必须同时运行。

派克的“并发”概念是有意的设计和实现决策。具有并发能力的程序设计可能会或可能不会表现出行为上的“并行性”。这取决于运行时环境。

您不希望非并发设计的程序表现出并行性。:-)但要在一定程度上获得相关因素（功耗，性能等）的净收益，则需要最大并发设计，以便主机系统可以在可能的情况下并行执行。

Pike的Go编程语言极端地说明了这一点：他的函数是可以同时正确运行的所有线程，即，调用函数始终会创建一个线程，如果系统能够，它将与调用方并行运行。具有数百甚至数千个线程的应用程序在他的世界中是完全普通的。（我不是围棋专家，这只是我的看法。）