并行编程发生在代码同时被执行并且每次执行都是相互独立的时候。因此，通常不会有关于共享变量之类的关注，因为那不太可能发生。

However, concurrent programming consists on code being executed by different processes/threads that share variables and such, therefore on concurrent programming we must establish some sort of rule to decide which process/thread executes first, we want this so that we can be sure there will be consistency and that we can know with certainty what will happen. If there is no control and all threads compute at the same time and store things on the same variables, how would we know what to expect in the end? Maybe a thread is faster than the other, maybe one of the threads even stopped in the middle of its execution and another continued a different computation with a corrupted (not yet fully computed) variable, the possibilities are endless. It's in these situations that we usually use concurrent programming instead of parallel.

我会试着用我自己的方式来解释它，它可能不是计算机术语，但它能给你一个大概的概念。

让我们以家务为例:洗碗，倒垃圾，修剪草坪等，我们有三个人(线程)A, B, C来做这些事情

并发: 三个人独立地开始不同的任务，例如，

A --> cleaning dishes
B --> taking out trash 
C --> mowing the lawn 

在这里，任务的顺序是不确定的，响应取决于工作量

并行: 在这里，如果我们想要提高吞吐量，我们可以分配多个人来完成一项任务，例如，清洁盘子，我们分配两个人，A擦洗盘子，B洗盘子，这可能会提高吞吐量。

洗碗:

A --> soaping the dishes
B --> washing the dishes

等等

希望这能给你一些启发!现在转到其他答案中解释的技术术语;)

Concurrent programming regards operations that appear to overlap and is primarily concerned with the complexity that arises due to non-deterministic control flow. The quantitative costs associated with concurrent programs are typically both throughput and latency. Concurrent programs are often IO bound but not always, e.g. concurrent garbage collectors are entirely on-CPU. The pedagogical example of a concurrent program is a web crawler. This program initiates requests for web pages and accepts the responses concurrently as the results of the downloads become available, accumulating a set of pages that have already been visited. Control flow is non-deterministic because the responses are not necessarily received in the same order each time the program is run. This characteristic can make it very hard to debug concurrent programs. Some applications are fundamentally concurrent, e.g. web servers must handle client connections concurrently. Erlang, F# asynchronous workflows and Scala's Akka library are perhaps the most promising approaches to highly concurrent programming.

Multicore programming is a special case of parallel programming. Parallel programming concerns operations that are overlapped for the specific goal of improving throughput. The difficulties of concurrent programming are evaded by making control flow deterministic. Typically, programs spawn sets of child tasks that run in parallel and the parent task only continues once every subtask has finished. This makes parallel programs much easier to debug than concurrent programs. The hard part of parallel programming is performance optimization with respect to issues such as granularity and communication. The latter is still an issue in the context of multicores because there is a considerable cost associated with transferring data from one cache to another. Dense matrix-matrix multiply is a pedagogical example of parallel programming and it can be solved efficiently by using Straasen's divide-and-conquer algorithm and attacking the sub-problems in parallel. Cilk is perhaps the most promising approach for high-performance parallel programming on multicores and it has been adopted in both Intel's Threaded Building Blocks and Microsoft's Task Parallel Library (in .NET 4).

我的理解是:

1)并发-使用共享资源串联运行 2)使用不同的资源并行运行

所以你可以让两件事情同时发生，即使它们在点(2)聚集在一起，或者两件事情在整个执行的操作中占用相同的储备(1)。

并发性和并行性源

在单个处理器上的多线程进程中，处理器可以在线程之间切换执行资源，从而实现并发执行。

在共享内存多处理器环境中的同一个多线程进程中，进程中的每个线程可以同时在单独的处理器上运行，从而导致并行执行。

当进程的线程数量与处理器数量相同或较少时，线程支持系统结合操作环境确保每个线程运行在不同的处理器上。

例如，在具有相同数量的线程和处理器的矩阵乘法中，每个线程(和每个处理器)计算结果的一行。

https://joearms.github.io/published/2013-04-05-concurrent-and-parallel-programming.html

并发=两个队列和一台咖啡机。

并行=两个队列和两个咖啡机。