进程和线程有什么区别？

Question

流程和线程之间的技术差异是什么？

我感觉像'过程'这样的词被过度使用，还有硬件和软件线程。像Erlang这样的语言轻量级进程怎么样？是否有明确的理由使用一个术语而不是另一个术语？

Answer 1

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

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

Erlang使用术语“进程”，因为它不公开共享内存多道程序设计模型。称他们为“线程”意味着他们共享内存。

Answer 2

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

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

---

在MSDN上找到这个：
 About Processes and Threads

  

Microsoft Windows支持抢占式多任务处理，它可以创建从多个进程同时执行多个线程的效果。在多处理器计算机上，系统可以同时执行与计算机上的处理器一样多的线程。

Answer 3

<强>过程：

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

<强>发

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

我从Knowledge Quest! blog借用了上述信息。

Answer 4

首先，让我们看一下理论方面。您需要了解流程在概念上理解流程和线程之间的区别以及它们之间共享的内容。

我们在Tanenbaum的Modern Operating Systems 3e中的 2.2.2经典线程模型部分中有以下内容：

  

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

他继续说道：

  

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

再向下，他提供了下表：

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

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

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

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

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

内核线程除了将所有调度问题留给操作系统外，还具有能够使用阻塞I / O的优点。但是每个线程切换都需要陷入内核，这可能相对较慢。但是，如果由于I / O阻塞而切换线程，这实际上不是问题，因为I / O操作可能已经把你困在了内核中。

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

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

Answer 5

解释有关并发编程的更多信息

1. 进程具有自包含的执行环境。进程通常具有完整的私有基本运行时资源集;特别是，每个进程都有自己的内存空间。

2. 线程存在于进程中 - 每个进程至少有一个进程。线程共享进程的资源，包括内存和打开文件。这可以实现有效但可能存在问题的沟通。

记住普通人，

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

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

Answer 6

  

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

here被盗。

Answer 7

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

Answer 8

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

Answer 9

进程和线程的真实示例 这将为您提供有关线程和进程的基本概念

我从Scott Langham的答案借用了上述信息 - 谢谢

Answer 10

流程：

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

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

<强>主题：

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

示例：
在浏览器中打开多个选项卡。

Answer 11

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

过程

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

主题

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

- 来自Galvin的操作系统

Answer 12

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

• 共享资源（线程按定义共享内存，它们除了堆栈和局部变量之外没有任何其他内容;进程也可以共享内存，但是有一个单独的机制，由OS维护）
• 分配空间（进程的内核空间与线程的用户空间）

上面的Greg Hewgill关于“进程”这个词的Erlang含义是正确的，here讨论了为什么Erlang可以轻量化进程。

Answer 13

尝试回答有关Java世界的这个问题。

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

例如：

示例1： JVM在单个进程中运行，JVM中的线程共享属于该进程的堆。这就是几个线程可以访问同一个对象的原因。线程共享堆并拥有自己的堆栈空间。这是一个线程调用方法及其局部变量的方式与其他线程保持线程安全的方式。但是堆不是线程安全的，必须同步才能保证线程安全。

示例2： 程序可能无法通过读取击键来绘制图片。该程序必须充分注意键盘输入，并且缺乏一次处理多个事件的能力将导致麻烦。解决此问题的理想方法是同时无缝地执行程序的两个或多个部分。线程允许我们这样做。这里绘制图片是一个过程，阅读按键是子过程（线程）。

Answer 14

Difference between Thread and Process?

进程是应用程序的执行实例，而线程是进程内的执行路径。此外，一个进程可以包含多个线程。重要的是要注意一个线程可以执行进程可以执行的任何操作。但由于进程可以包含多个线程，因此可以将线程视为“轻量级”进程。因此，线程和进程之间的本质区别是每个人用来完成的工作。线程用于小任务，而进程用于更多“重量级”任务 - 基本上是应用程序的执行。

线程和进程之间的另一个区别是同一进程中的线程共享相同的地址空间，而不同的进程则不共享。这允许线程读取和写入相同的数据结构和变量，并且还促进线程之间的通信。流程之间的通信（也称为IPC或进程间通信）非常困难且资源密集。

  

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

1. 线程比流程更容易创建 不需要单独的地址空间。

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

3. 线程被认为是轻量级的，因为它们使用很远 资源少于流程。

4. 流程彼此独立。线程，因为他们 共享相同的地址空间是相互依赖的，所以要小心 必须采取不同的线程不相互踩 这是说明上述＃2的另一种方式。

5. 进程可以包含多个线程。

Answer 15

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

  

Linus Torvalds（torvalds@cs.helsinki.fi）

     

Tue，1996年8月6日12:47:31 +0300（EET DST）

     

按以下顺序排列的消息：[日期] [主题] [主题] [作者]

     

下一条消息：Bernd P. Ziller：＆＃34; Re：在get_hash_table中哎呀＆＃34;

     

上一条消息：Linus Torvalds：＆＃34; Re：I / O请求订购＆＃34;

     

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

     

    

我们需要明确线程的概念。太多人     似乎把一个线程与一个进程混淆了。以下讨论     不反映linux的当前状态，而是一个     试图保持高水平的讨论。

  

     

NO！

     

没有理由认为＆＃34;线程＆＃34;和＆＃34;进程＆＃34;是   单独的实体。这就是它传统的做法，但我   个人认为这样做是一个很大的错误。唯一的   有理由认为这种方式是历史包袱。

     

线程和进程实际上只是一件事：＆＃34;上下文   执行＆＃34 ;.试图人为地区分不同的案例是公正的   自限性。

     

A＆＃34;执行的背景＆＃34;，在此称为COE，只是集团   该COE的所有状态。该状态包括CPU等   状态（寄存器等），MMU状态（页面映射），权限状态   （uid，gid）和各种＆＃34;通信状态＆＃34; （打开文件，信号   处理程序等）。传统上，＆＃34;线程＆＃34;和a   ＆＃34;处理＆＃34;主要是线程有CPU状态（+可能   一些其他的最小状态），而所有其他的上下文来自   处理。但是，那是公正的   一种分割COE总状态的方式，没有任何东西可以说它是正确的方法。限制自己   这种形象只是愚蠢的。

     

Linux对此的看法（以及我希望工作的方式）是   那个 没有＆＃34;过程＆＃34;或者＆＃34;线程＆＃34;。有   只有COE的全部（称为＆＃34;任务＆＃34;由Linux）。不同的COE   可以相互分享其上下文的一部分，以及一个子集   分享是传统的＆＃34;线程＆＃34; /＆＃34;过程＆＃34;设置，但那   应该被视为仅仅是一个子集（它是一个重要的子集，但是   重要性不是来自设计，而是来自标准：我们很明智   想在Linux上运行符合标准的线程程序   太）。

     

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

     

就像你认为COE一样可能的例子   与线程/进程相对：

     

  
• 你可以做一个外部的＆＃34; cd＆＃34;程序，在UNIX和/或进程/线程中传统上不可能的东西（愚蠢的例子，但想法   是你可以拥有这些＆＃34;模块＆＃34;并不仅限于此   传统的UNIX /线程设置）。做一个：
  

     

克隆（CLONE_VM | CLONE_FS）;

     

child：execve（＆＃34; external-cd＆＃34;）;

     

/ *＆＃34; execve（）＆＃34;将取消关联VM，这是我们唯一的原因   使用CLONE_VM是为了使克隆行为更快* /

     

  
• 你可以做＆＃34; vfork（）＆＃34;自然（它需要最小的内核支持，但这种支持完全符合CUA的思维方式）：
  

     

克隆（CLONE_VM）;

     

孩子：继续跑，最后execve（）

     妈妈：等待execve

     

  
• 你可以做外部＆＃34; IO deamons＆＃34;：
  

     

克隆（CLONE_FILES）;

     

child：打开文件描述符等

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

     

以上所有工作都是因为您与线程/进程无关   思维方式。想象一下Web服务器，例如CGI   脚本作为＆＃34;执行线程完成＆＃34;。你无法做到这一点   传统线程，因为传统线程总是必须共享   整个地址空间，所以你必须链接你曾经的一切   想要在网络服务器本身做（一个＆＃34;线程＆＃34;不能运行另一个   可执行文件）。

     

将此视为执行的背景＆＃34;问题而不是你的   任务现在可以选择执行外部程序（=分开   来自父母的地址空间）等等，如果他们想要，或者他们可以   示例与文件的父除共享所有内容   描述符（这样子＆＃34;线程＆＃34;可以打开很多文件而不用   父母需要担心他们：他们何时自动关闭   子＆＃34;线程＆＃34;退出，并且它不会在父母中使用fd。）。

     

例如，考虑一个线程＆＃34; inetd＆＃34;。你想要低开销   fork + exec，所以用Linux方式你可以代替使用＆＃34; fork（）＆＃34;   你编写了一个多线程inetd，其中每个线程都是用它创建的   只是CLONE_VM（共享地址空间，但不要共享文件描述符   等等）。如果是外部服务，孩子可以执行（rlogind，   例如），或者它可能是内部inetd服务之一   （echo，timeofday）在这种情况下它只是做它的事情并退出。

     

你不能用＆＃34;线程＆＃34; /＆＃34;处理＆＃34;

     

莱纳斯

Answer 16

以下是我从The Code Project的一篇文章中得到的内容。我想它清楚地解释了所有需要的东西。

  

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

Answer 17

从采访者的角度来看，基本上只有3个主要内容我想听，除了明显的事情，比如一个过程可以有多个线程：

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

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

Answer 18

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

线程：线程是一个功能，它与程序的其他部分一起执行，基于“one with other”的概念，因此线程是进程的一部分..

Answer 19

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

Answer 20

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

Answer 21

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

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

另一方面，

进程生活在由MMU提供和保护的私有虚拟内存沙箱中。这很方便，因为它可以实现：

1. 防止错误进程导致整个系统崩溃。
2. 通过使其他进程数据不可见来维护安全性 不可达。 流程中的实际工作由一个或多个线程处理。

Answer 22

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

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

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

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

正如之前的帖子中所提到的，进程和线程都是独立的顺序执行，主要区别在于内存在进程的多个线程之间共享，而进程隔离了它们的内存空间。

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

¹ Donald Knuth对“计算机编程艺术：基本算法”中的解释程序有很好的解释。

Answer 23

对于那些通过可视化学习更加舒适的人来说，这是我为解释过程和线程而创建的一个方便的图表。
我使用了MSDN中的信息 - About Processes and Threads

Answer 24

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

程序在启动到内存时成为一个过程。进程有自己的地址空间，意味着在内存中有各种段，例如用于存储已编译代码的.text段，用于存储未初始化的静态或全局变量的.bss等。每个进程都有自己的程序计数器和用户spcae 堆。在内核中，每个进程都有自己的内核堆栈（为了安全问题而与用户空间堆栈分开）和一个名为task_struct的结构，它通常被抽象为进程控制块，存储有关进程的所有信息。作为其优先权，州，（以及许多其他大块）。一个进程可以有多个执行线程。

进入线程，它们驻留在进程内并共享父进程的地址空间以及可在线程创建期间传递的其他资源，例如文件系统资源，共享挂起信号，共享数据（变量和指令），从而制作线程轻量级，因此允许更快的上下文切换在内核中，每个线程都有自己的内核堆栈以及定义线程的task_struct结构。因此，内核查看与不同实体相同的进程的线程，并且可以自己调度。同一进程中的线程共享一个称为线程组ID（tgid）的公共ID，它们也有一个唯一的id，称为进程ID（pid）。

Answer 25

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

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

Answer 26

我到目前为止找到的最佳答案是Michael Kerrisk's 'The Linux Programming Interface'：

  

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

这本书非常清晰; Julia Evans在this article中提到了帮助清理Linux组的真正工作方式。

Answer 27

最佳答案

过程：

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

线程：

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

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

Answer 28

它们几乎一样......但关键的区别在于线程是轻量级的，并且在上下文切换，工作负载等方面过程都很重。

Answer 29

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

线程是可分派的执行单元，或者简单来说就是指令序列的进展

Answer 30

示例1：JVM在单个进程中运行，JVM中的线程共享属于该进程的堆。这就是几个线程可以访问同一个对象的原因。线程共享堆并拥有自己的堆栈空间。这是一个线程调用方法及其局部变量的方式与其他线程保持线程安全的方式。但是堆不是线程安全的，必须同步才能保证线程安全。

Answer 31

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

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

Answer 32

我认为了解差异的最简单方法是可视化线程和进程如何执行其作业。

---

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

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

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

---

进程 正在并行并发运行：

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

Answer 33

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

Erlang实现了抢占式调度程序，该调度程序允许每个进程在设定的时间段内运行，而不会阻塞系统线程太长时间，这使每个进程都有一定的cpu时间可以执行。如果我没有记错的话，系统线程的数量取决于内核的数量，并且如果负载变得不均匀，则可以从一个线程中删除进程，然后将进程移至另一个线程，这全部由Erlang调度程序处理。

Answer 34

我已经仔细阅读了几乎所有的答案，可惜，作为一名正在学习OS课程的本科生，我无法完全理解这两个概念。我的意思是大多数人都从某些OS书籍中读到了差异，即线程能够使用事务的地址空间访问事务单元中的全局变量。但是，新的问题提出了为什么要有进程，众所周知，我们已经知道线程相对于进程而言是更轻量级的。让我们通过使用one of the prior answers

中摘录的图像来看看下面的示例

我们有3个线程同时处理一个word文档，例如Libre Office。第一个通过下划线强调单词是否拼写来进行拼写检查。第二个接收并打印键盘上的字母。最后一个确实在每一次短时间内都保存了文档，以防万一出了问题而丢失了工作文档。 在这种情况下，这3个线程不能是3个进程，因为它们共享一个公共内存，这是其进程的地址空间，因此所有人都可以访问正在编辑的文档。文档以及两个推土机，它们是线程，尽管图像中缺少其中之一。

Answer 35

进程-执行中的程序

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

例如，要计算矩阵乘法，您将为main内的循环编写一个3的程序并执行它。 现在，这就是您的过程。

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

在两种情况下结果都是相同的。

Answer 36

线程是一个轻量级进程，而进程是一个自包含的执行环境。

“自包含执行过程”是什么意思？ 一组私有的基本运行时资源。

“基本运行时资源的私有集”是什么意思？ 从内存中分配的空间来运行进程。（简单的内存空间。）