进程和线程有什么区别？

进程和线程都是独立的执行序列。典型的区别是（同一进程的）线程在共享内存空间中运行，而进程在单独的内存空间中运行。

我不确定你指的是什么“硬件”和“软件”线程。线程是一种操作环境特性，而不是CPU特性（尽管CPU通常具有使线程高效的操作）。

Erlang使用术语“进程”是因为它没有公开共享内存多道程序模型。称它们为“线程”意味着它们具有共享内存。

应用程序由一个或多个进程组成。进程，用最简单的术语来说，是一个正在执行的程序。一个或多个线程在进程的上下文中运行。线程是操作系统分配处理器时间的基本单元。线程可以执行进程代码的任何部分，包括当前正由另一个线程执行的部分。光纤是一个执行单元，必须由应用程序手动调度。光纤在调度它们的线程的上下文中运行。

偷来的这里

线程和进程都是OS资源分配的原子单元（即有一个描述CPU时间如何在它们之间分配的并发模型，以及拥有其他OS资源的模型）。有以下区别：

• 共享资源（线程根据定义共享内存，除了堆栈和局部变量之外，它们不拥有任何东西；进程也可以共享内存，但有一个单独的机制，由OS维护）
• 分配空间（进程的内核空间与线程的用户空间）

上面的Greg Hewgill对“进程”这个词的Erlang含义是正确的，这里有一个关于为什么Erlang可以做轻量级进程的讨论。

进程是代码、内存、数据和其他资源的集合。线程是在进程范围内执行的代码序列。您可以（通常）在同一个进程中同时执行多个线程。

此信息可在Microsoft Learning此处找到：关于进程和线程

流程
每个过程提供执行程序所需的资源。进程具有虚拟地址空间、执行代码、系统对象的打开句柄、安全上下文、唯一进程识别号、环境变量、优先级类、最小和最大工作集大小以及至少一个执行线程。每个进程以单个线程启动，通常称为主线，但可以从其任何线程创建其他线程。

线程
线程是进程内可以调度执行的实体。进程的所有线程共享其虚拟地址空间和系统资源。此外，每个线程维护异常处理程序、调度优先级、线程本地存储、唯一线程标识符以及一组系统将用于保存线程上下文直到被调度的结构。线程上下文包括线程的机器寄存器集、内核堆栈、线程环境块和线程进程地址空间中的用户堆栈。线程也可以有自己的安全上下文，可用于模拟客户端。

Microsoft Windows支持先发制人的多任务处理，它创建了从多个进程同时执行多个线程的效果。在多处理器计算机上，系统可以同时执行计算机上有多少处理器的线程。

我从知识探索！博客复制了这个信息：

过程：

• 程序的执行实例称为进程。
• 一些操作系统使用术语“任务”来指代正在执行的程序。
• 进程总是存储在主存储器中，也称为主存储器或运行内存。
• 因此，进程被称为活动实体。如果机器重新启动，它就会消失。
• 几个进程可以与同一个程序相关联。
• 在多处理器系统上，多个进程可以并行执行。
• 在单处理器系统上，虽然没有实现真正的并行性，但应用了进程调度算法，处理器被计划一次执行一个进程产生一个假象的并发。
• 示例：执行“计算器”程序的多个实例。每个实例都称为进程。

主题：

• 线程是进程的子集。
• 它被称为“轻量级进程”，因为它类似于真正的进程，但在进程的上下文中执行并共享内核分配给进程的相同资源。
• 通常，一个进程只有一个控制线程——一次执行一组机器指令。
• 进程也可以由并发执行指令的多个执行线程组成。
• 多个控制线程可以利用多处理器系统上可能的真正并行性。
• 在单处理器系统上，应用线程调度算法，处理器被调度为一次运行一个线程。
• 进程中运行的所有线程共享相同的地址空间、文件描述符、堆栈和其他与进程相关的属性。
• 由于进程的线程共享相同的内存，因此同步访问进程内的共享数据获得了前所未有的收益重要性

1. 线程在共享内存空间中运行，但进程在单独的内存空间中运行
2. 线程是一个轻量级进程，但进程是一个重量级进程。
3. 线程是进程的子类型。

关于并发编程的更多解释

进程有一个自包含的执行环境。进程通常有一组完整的、私有的基本运行时资源；特别是，每个进程都有自己的内存空间。

线程存在于进程中-每个进程至少有一个。线程共享进程的资源，包括内存和打开的文件。这使得通信高效，但可能存在问题。

来源：Java™教程：进程和线程

一个让普通人记住的例子：

在您的计算机上，打开Microsoft Word和Web浏览器。我们称这两个为过程。

在Microsoft Word中，您键入一些内容并自动保存。现在，您已经观察到编辑和保存并行发生-在一个线程上编辑并在另一个线程上保存。

流程：正在执行的程序称为进程

线程：线程是一个功能，它与程序的其他部分一起执行，基于“一个与其他”的概念，所以线程是进程的一部分。

以下是我从代码项目的一篇文章中得到的。我想它清楚地解释了所有需要的东西。

线程是另一种将工作负载拆分为单独的机制执行流。线程的重量比进程轻。这这意味着，它提供的灵活性不如一个完整的过程，但可以更快地启动，因为操作系统的启动时间更少设置。当程序由两个或多个线程组成时，所有线程共享一个内存空间。进程被赋予单独的地址空间。所有线程共享一个堆。但每个线程都有自己的堆栈。

试图回答这个与世界有关Java问题。

进程是程序的执行，但线程是进程中的单个执行序列。进程可以包含多个线程。线程有时称为轻量级工艺。

例如：

示例1：JVM在单个进程中运行，JVM中的线程共享属于该进程的堆。这就是为什么多个线程可能访问同一个对象。线程共享堆并有自己的堆栈空间。这就是一个线程对方法及其局部变量的调用如何与其他线程保持线程安全。但是堆不是线程安全的，必须为了线程安全而同步。

示例2：程序可能无法通过读取击键来画图。程序必须全神贯注于键盘输入，并且缺乏一次处理多个事件的能力会导致麻烦。这个问题的理想解决方案是同时无缝执行程序的两个或多个部分。线程允许我们这样做。在这里画图是一个进程，读取击键是子进程（线程）。

• 每个进程都是一个线程（主线程）。
• 但是每个线程都不是一个进程。它是进程的一部分（实体）。

首先，让我们看看理论方面。您需要从概念上理解进程是什么，才能理解进程和线程之间的区别以及它们之间共享的内容。

我们在Tanenbaum的现代操作系统3e的2.2.2经典线程模型部分中有以下内容：

流程模型基于两个独立的概念：资源分组和执行。有时将它们分开是有用的；这就是线程进来的地方……

他继续说：

看待进程的一种方式是，它是一种将相关资源组合在一起。进程有一个地址空间包含程序文本和数据，以及其他资源。这些资源可能包括打开的文件、子进程、挂起的警报、信号处理程序，会计信息等等。通过将它们它们以流程的形式结合在一起，可以更容易地管理。进程的另一个概念通常是执行线程缩短为只是线程。线程有一个程序计数器，它保持跟踪下一步要执行的指令。它有寄存器，它保存其当前工作变量。它有一个堆栈，其中包含执行历史，每个过程有一个帧被调用但没有尽管线程必须在某个进程中执行，但线程及其过程是不同的概念，可以处理进程用于将资源组合在一起；线程是计划在CPU上执行的实体。

接下来，他提供了下表：

Per process items             | Per thread items------------------------------|-----------------Address space                 | Program counterGlobal variables              | RegistersOpen files                    | StackChild processes               | StatePending alarms                |Signals and signal handlers   |Accounting information        |

让我们来处理一下硬件多线程的问题。经典地，CPU将支持单个线程的执行，通过单个程序计数器（PC）和一组寄存器维护线程的状态。但是当缓存未命中时会发生什么？从主存中获取数据需要很长时间，而当这种情况发生时，CPU只是闲置在那里。所以有人有了一个想法，基本上有两组线程状态（PC+寄存器），这样另一个线程（可能在同一个进程中，也可能在不同的进程中）可以在另一个线程等待主存的时候完成工作。这个概念有多个名称和实现，例如超线程和同时多线程（简称SMT）。

现在让我们看看软件方面。基本上有三种方法可以在软件方面实现线程。

1. 用户空间线程
2. 内核线程
3. 两者的结合

实现线程只需要能够保存CPU状态并维护多个栈，这在很多情况下可以在用户空间完成。用户空间线程的优点是超快的线程切换，因为你不必陷入内核并且能够按照你喜欢的方式调度线程。最大的缺点是无法进行阻塞I/O（这将阻塞整个进程及其所有用户线程），这是我们首先使用线程的重要原因之一。使用线程阻塞I/O在许多情况下大大简化了程序设计。

内核线程除了将所有调度问题留给操作系统之外，还具有能够使用阻塞I/O的优势。但是每个线程切换都需要捕获到内核中，这可能相对较慢。然而，如果你因为阻塞的I/O而切换线程，这不是真正的问题，因为I/O操作可能已经将你捕获到内核中了。

另一种方法是将两者结合起来，使用多个内核线程，每个线程都有多个用户线程。

所以回到你的术语问题上，你可以看到进程和执行线程是两个不同的概念，你选择使用哪个术语取决于你在谈论什么。关于“轻量级进程”这个术语，我个人不明白它的意义，因为它并没有真正传达正在发生的事情以及“执行线程”这个术语。

线程和进程之间的区别？

线程是进程中执行的路径。此外，一个进程可以包含多个线程。

线程和进程之间的另一个区别是，同一进程中的线程共享相同的地址空间，而不同的进程不共享。这允许线程读写相同的数据结构和变量，也方便了线程之间的通信。进程之间的通信-也称为IPC或进程间通信-相当困难且资源密集型。

以下是线程和进程之间差异的摘要：

1. 线程比进程更容易创建，因为它们不需要单独的地址空间。

2. 多线程需要仔细编程，因为线程共享只能由一个线程修改的数据结构与线程不同，进程不共享相同的地址空间。

3. 线程被认为是轻量级的，因为它们使用远距离资源比进程少。

4. 进程相互独立。线程，因为它们共享相同的地址空间是相互依存的，所以要小心必须采取这样不同的线程不会相互踩踏。
   这实际上是上面第二种说法的另一种方式。

5. 一个进程可以由多个线程组成。

它们几乎一样……但关键的区别是线程是轻量级的，而进程在上下文切换、工作负载等方面是重量级的。

两个进程不能共享资源（例外情况是，如果一个进程（父进程）分叉创建另一个进程（子进程），默认情况下可以共享资源），对CPU的资源要求很高，而线程在这种情况下的负载要轻得多。虽然两者拥有相同的东西。

示例1：JVM在单个进程中运行，JVM中的线程共享属于该进程的堆。这就是为什么多个线程可能访问同一个对象。线程共享堆并有自己的堆栈空间。这就是一个线程对方法及其局部变量的调用如何与其他线程保持线程安全。但堆不是线程安全的，必须为了线程安全而同步。

从面试官的角度来看，基本上只有3个我想听到的主要内容，除了像进程可以有多个线程这样明显的东西：

1. 线程共享相同的内存空间，这意味着一个线程可以从其他线程内存访问内存。进程通常不能。
2. 资源（内存、句柄、套接字等）在进程终止时释放，而不是线程终止。
3. 安全性。进程具有固定的安全令牌。另一方面，线程可以模拟不同的用户/令牌。

如果你想要更多，Scott Langham的回答几乎涵盖了一切。所有这些都是从操作系统的角度来看的。不同的语言可以实现不同的概念，例如任务、轻型线程等，但它们只是使用线程（Windows上的光纤）的方式。没有硬件和软件线程。有硬件和软件例外和中断，或者用户模式和内核线程。

进程和线程都是独立的执行序列。典型的区别是（同一进程的）线程在共享内存空间中运行，而进程在单独的内存空间中运行。

流程

是一个执行中的程序。它有文本部分，即程序代码、由程序计数器值表示的当前活动和处理器寄存器的内容。它还包括包含临时数据（如函数参数、返回寻址和局部变量）的进程堆栈，以及包含全局变量的数据部分。进程还可能包括堆，堆是在进程运行时动态分配的内存。

线程

线程是CPU利用率的基本单位；它包括线程ID、程序计数器、寄存器集和堆栈。它与属于同一进程的其他线程共享其代码部分、数据部分和其他操作系统资源，例如打开的文件和信号。

-取自Galvin的操作系统

在使用Python（解释语言）构建包含多线程的算法时，我惊讶地发现，与我之前构建的顺序算法相比，执行时间并没有更好。为了理解这个结果的原因，我做了一些阅读，并相信我所学到的提供了一个有趣的上下文，可以更好地理解多线程和多进程之间的区别。

多核系统可能会执行多个线程，因此Python应该支持多线程。但Python不是一种编译语言，而是一种解释性语言¹。这意味着程序必须被解释才能运行，解释器在程序开始执行之前并不知道程序。然而，它所知道的是Python的规则，然后动态地应用这些规则。Python中的优化必须主要是对解释器本身的优化，而不是要运行的代码。这与C++等编译语言形成鲜明对比，并对Python中的多线程有影响。具体来说，Python使用全局解释器锁来管理多线程。

另一方面，编译语言是编译的。程序被“完全”处理，首先根据其语法定义进行解释，然后映射到与语言无关的中间表示，最后链接到执行代码中。这个过程允许代码高度优化，因为它在编译时全部可用。各种程序交互和关系在创建可执行文件时被定义，并且可以做出有关优化的强大决策。

在现代环境中，Python的解释器必须允许多线程，这必须既安全又高效。这就是解释型语言与编译型语言之间的区别。解释器必须不干扰来自不同线程的内部共享数据，同时优化处理器的计算使用。

正如历史发文所指出的，进程和线程都是独立的顺序执行，主要区别在于内存在进程的多个线程之间共享，而进程隔离其内存空间。

在Python中，全局解释器锁保护数据不被不同的线程同时访问。它要求在任何Python程序中任何时候只能执行一个线程。另一方面，由于每个进程的内存与任何其他进程隔离，因此可以运行多个进程内核。

¹ Donald Knuth在《计算机编程艺术：基本算法》中对解释例程有很好的解释。

来自嵌入式世界，我想补充一点，进程的概念只存在于具有MMU（内存管理单元）的“大”处理器（桌面CPU，ARM Cortex A-9）和支持使用MMU的操作系统（例如Linux）。对于小型/旧处理器和微控制器以及小型RTOS操作系统（实时操作系统），例如freeRTOS，没有MMU支持，因此没有进程，只有线程。

线程可以访问彼此的内存，它们由操作系统以交错的方式调度，因此它们看起来并行运行（或者使用多核它们实际上并行运行）。

另一方面，进程住在他们的虚拟内存沙盒中，由MMU提供和保护。这很方便，因为它可以：

1. 防止错误进程使整个系统崩溃。
2. 通过使其他进程数据不可见来维护安全性无法访问。进程内部的实际工作由一个或多个线程负责。

同一进程内的线程共享内存，但每个线程都有自己的堆栈和寄存器，线程将线程特定的数据存储在堆中。线程从不独立执行，因此与进程间通信相比，线程间通信要快得多。

进程永远不会共享相同的内存。当子进程创建时，它会复制父进程的内存位置。进程通信是通过使用管道、共享内存和消息解析来完成的。线程之间的上下文切换非常慢。

将进程视为所有权单元或任务需要哪些资源。进程可以拥有内存空间、特定输入/输出、特定文件和优先级等资源。

线程是一个可调度的执行单元，或者简单地说，通过一系列指令的进展

试图从Linux内核的操作系统视图中回答它

当程序进入内存时，它就变成了一个进程。进程有自己的地址空间，这意味着在内存中具有各种段，例如用于存储编译代码的.text段，用于存储未初始化的静态或全局变量的.bss等。
每个进程都有自己的程序计数器和用户空间堆栈。

在内核中，每个进程都有自己的内核堆栈（由于安全问题与用户空间堆栈分离）和一个名为task_struct的结构，该结构通常被抽象为进程控制块，存储有关进程的所有信息，例如其优先级、状态（以及大量其他块）。

在内核中，每个线程都有自己的内核栈以及定义线程的task_struct结构。因此内核将同一进程的线程视为不同的实体，并且本身是可调度的。同一进程中的线程共享一个公共id，称为线程组id（tgid），它们也有一个唯一的id，称为进程id（pid）。

进程和线程的真实世界示例这将给你关于线程和进程的基本概念

我从Scott Langham的回答中借用了上述信息谢谢

1. 基本上，线程是进程的一部分，没有进程线程就无法工作。
2. 线程是轻量级的，而进程是重量级的。
3. 进程之间的通信需要一些时间，而线程需要更少的时间。
4. 线程可以共享相同的内存区域，而进程可以单独存在。

过程：

1. 过程是一个沉重的过程。
2. 进程是一个单独的程序，具有单独的内存、数据、资源等。
3. 进程是使用fork（）方法创建的。
4. 进程之间的上下文切换很耗时。
   

示例：
比如说，打开任何浏览器（mozilla、Chrome、IE）。此时新进程将开始执行。

线程：

1. 线程是轻量级进程。
2. 线程具有共享内存、数据、资源、文件等。
3. 线程是使用clone（）方法创建的。
4. 线程之间的上下文切换不像进程那样耗时。
   

到目前为止我找到的最好的答案是迈克尔·克瑞斯的《Linux编程接口》：

在现代UNIX实现中，每个进程可以有多个线程一种设想线程的方法是作为一组进程共享相同的虚拟内存，以及一系列其他属性。每个线程都在执行相同的程序代码并共享相同的数据区域和堆。但是，每个线程都有自己的堆栈包含局部变量和函数调用链接信息。[LPI 2.12]

这本书是一个非常清晰的来源；朱莉娅·埃文斯提到它有助于澄清Linux团体在这篇文章中的真正工作方式。

对于那些更喜欢通过可视化学习的人来说，这是我创建的一个方便的图表来解释进程和线程。
我使用了来自MSDN的信息-关于进程和线程

http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html

莱纳斯·托瓦兹（torvalds@cs.helsinki.fi）

Tue，6 Aug 1996 12:47:31+0300（EET DST）

消息排序：[日期][线程][主题][作者]

下一篇：Bernd P. Ziller：“Re： Oops inget_hash_table”

上一条消息：Linus Torvalds：“Re： I/O请求排序”

1996年8月5日，Peter P. Eiserloh写道：

我们需要清楚线程的概念。太多人了似乎混淆了线程和进程。以下讨论并不反映linux的当前状态，而是一个#36825；高层次的讨论

不！

没有理由认为“线程”和“进程”是独立的实体。传统上是这样做的，但我我个人认为那样想是个大错误。唯一有理由认为这种方式是历史包袱。

线程和进程实际上只是一件事：一个“上下文执行”。试图人为地区分不同的案件是公正的自限制。

“执行上下文”，特此称为COE，只是企业集团该COE的所有状态。该状态包括CPU之类的东西状态（寄存器等）、MMU状态（页面映射）、权限状态（uid、gid）和各种“通信状态”（打开文件、信号处理程序等）。传统上，“线程”和“进程”主要是指线程具有CPU状态（+可能其他最小状态），而所有其他上下文都来自过程。然而，这只是一个分割COE总状态的方法，没有任何东西表明这是正确的方法。限制自己这样的形象是愚蠢的。

Linux思考这个问题的方式（以及我希望事情顺利进行的方式）是是没有“进程”或“线程”这样的东西。有只有COE的整体（Linux称为“任务”）可以彼此共享部分上下文，并且其中一个子集共享是传统的“线程”/“进程”设置，但是应该被看作只是一个子集（它是一个重要的子集，但是这种重要性不是来自设计，而是来自标准：我们显然想要在Linux之上运行符合标准的线程程序也）。

简而言之：不要围绕线程/进程的思维方式进行设计。该内核应该围绕COE的思维方式设计，然后pthread图书馆可以将有限的pthread接口导出给用户谁想用这种方式看COE的。

作为一个例子，当你认为COE是可能的时候与线程/进程相反：

• 您可以执行外部“cd”程序，这在UNIX和/或进程/线程中传统上是不可能的（愚蠢的例子，但这个想法你可以拥有这些“模块”，而不仅限于传统的UNIX/线程设置）。执行：

克隆（CLONE_VM|CLONE_FS）；

孩子：执行（“外部CD”）；

/*“execve（）”将取消与VM的关联，因此我们唯一的原因是CLONE_VM是为了让克隆更快*/

• 您可以自然地执行“vforc（）”（它需要最少的内核支持，但这种支持完全符合CUA的思维方式）：

克隆（CLONE_VM）；

子进程：继续运行，最终执行（）

母亲：等待执行

• 您可以执行外部“IO deamons”：

克隆（CLONE_FILES）；

子：打开文件描述符等

妈妈：用孩子打开的fd和vv。

以上所有的工作，因为你没有绑定到线程/进程思维方式。例如，考虑一个Web服务器，其中CGI脚本作为“执行线程”完成。你不能用传统线程，因为传统线程总是要共享整个地址空间，所以你必须链接所有你曾经想要在Web服务器本身中执行（“线程”不能运行另一个线程）可执行）。

将此视为“执行上下文”问题，您的任务现在可以选择执行外部程序（=分离地址空间从父）等，如果他们想要，或者他们可以示例与文件的父级除了共享所有内容描述符（以便子“线程”可以打开大量文件而无需父母需要担心它们：它们会自动关闭子“线程”退出，并且它不会用完父级中的fd）。

例如，考虑一个线程“inetd”。您想要低开销fork+exec，所以你可以用Linux的方式而不是使用"fork（）"您编写一个多线程inetd，其中每个线程都是使用只需CLONE_VM（共享地址空间，但不共享文件描述符etc）。然后，如果它是外部服务（rlogind、例如），或者它可能是内部inetd服务之一（回显，timeofday）在这种情况下，它只是做它的事情并退出。

你不能用“线程”/“进程”做到这一点。

Linus

进程和线程之间的区别如下：

• 进程是程序的执行实例，而线程是进程的最小单元。
• 进程可以划分为多个线程，而线程不能划分。
• 进程可以被视为任务，而线程可以被视为任务轻量级进程。
• 进程分配单独的内存空间，而线程分配共享内存空间。
• 进程由操作系统维护，而线程由程序员维护。

来自Erlang Programming（2009）：Erlang并发快速且可扩展。它的进程是轻量级的，因为Erlang虚拟机不会为每个创建的进程创建一个操作系统线程。它们是在VM中创建、调度和处理的，独立于底层操作系统。

Erlang实现了一个抢占式调度器，它允许每个进程运行一段设定的时间，而不会阻塞系统线程太长时间，这给了每个进程一些CPU时间来执行。系统线程的数量取决于内核的数量，如果我没有弄错的话，可以从一个线程中删除进程，并在负载变得不均匀时移动到另一个线程，这都由Erlang调度器处理。

过程：

进程基本上是一个正在执行的程序。它是一个活动实体。一些操作系统使用术语“任务”来指代正在执行的程序。进程总是存储在主存储器中，也称为主存储器或运行内存。因此，进程被称为活动实体。如果机器重新启动，它就会消失。几个进程可以与同一个程序相关联。在多处理器系统上，多个进程可以并行执行。在单处理器系统上，虽然没有实现真正的并行性，但应用了进程调度算法，并且处理器被调度为一次执行一个进程，从而产生并发的错觉。示例：执行“计算器”程序的多个实例。每个实例都称为一个进程。

主题：

线程是进程的子集。它被称为“轻量级进程”，因为它类似于真正的进程，但在进程的上下文中执行，并共享内核分配给进程的相同资源。通常，一个进程只有一个控制线程——一次执行一组机器指令。进程也可以由并发执行指令的多个执行线程组成。多个控制线程可以利用多处理器系统上可能的真正并行性。在单处理器系统上，应用线程调度算法，处理器被调度为一次运行一个线程。进程中运行的所有线程共享相同的地址空间、文件描述符、堆栈和其他与进程相关的属性。由于进程的线程共享相同的内存，因此在进程中同步访问共享数据变得前所未有的重要。

ref-https://practice.geeksforgeeks.org/problems/difference-between-process-and-thread

那里的答案我都看过了，唉，作为目前选修操作系统课程的本科生，我不能完全理解这两个概念。我的意思是，大多数人从一些操作系统书籍中读到差异，即线程由于利用了进程的地址空间而能够访问事务单元中的全局变量。然而，新问题出现了为什么有进程，我们已经认识到线程相对于进程来说更轻量级。让我们通过使用先前的答案之一摘录的图像来查看以下示例，

我们有3个线程同时处理word文档，例如自由办公室。第一个通过下划线检查单词是否拼写错误。第二个从键盘上获取和打印字母。最后一个确实在短时间内保存文档，以免在出现问题时丢失文档。在这种情况下，3个线程不能是3个进程，因为它们共享一个公共内存，该内存是它们进程的地址空间，因此所有线程都可以访问正在编辑的文档。所以，道路是word文档以及两个推土机，它们是线程，尽管其中一个在图像中缺少。

进程-执行中的程序

线程-线程是执行最小的编程指令序列

Eg-你想计算矩阵乘法，你将在main中编写一个3 for循环的程序并执行它。这就是你的过程

现在，您可以通过创建线程并分配每个线程来执行行的结果来解决同一个程序。每个线程将独立工作，结果将存储在一个数组中。因为线程在进程内共享相同的内存。

在这两种情况下，结果将是相同的。

我相信理解差异的最简单方法是可视化线程和进程如何执行它们的作业。

线程在共享内存空间（创建它们的进程）中运行并行：

Thread 1              Thread 2              Thread 3||||||||||||Complete             Complete              Complete

注意：以上可以解释为一个进程（即一个进程有3个线程）

进程正在运行并行和同时：

Process 1              Process 2              Process 3|                      |                      ||                      |                      ||                      |                      ||                      |                      ||                      |                      ||                      |                      |Complete               Complete               Complete