What is the difference between a process and a thread?
流程和线程之间的技术差异是什么？
我觉得像"进程"这样的词被过度使用，还有硬件和软件线程。像Erlang这样的语言的轻量级进程如何？是否有明确的理由使用一个术语而不是另一个？
进程和线程都是独立的执行序列。典型的区别是(同一进程的)线程在共享内存空间中运行，而进程在单独的内存空间中运行。
我不确定您可能指的是什么"硬件"和"软件"线程。线程是操作环境特性，而不是CPU特性(尽管CPU通常具有使线程高效的操作)。
Erlang使用术语"进程"，因为它不公开共享内存多道程序设计模型。称它们为"线程"意味着它们有共享的内存。
过程每个进程提供执行程序所需的资源。进程具有虚拟地址空间、可执行代码、系统对象的打开句柄、安全上下文、唯一进程标识符、环境变量、优先级类、最小和最大工作集大小以及至少一个执行线程。每个进程都是用一个线程(通常称为主线程)启动的，但是可以从它的任何线程创建额外的线程。
螺纹线程是进程中可以计划执行的实体。进程的所有线程共享其虚拟地址空间和系统资源。此外，每个线程都维护异常处理程序、调度优先级、线程本地存储、唯一的线程标识符以及系统在调度线程上下文之前将用于保存线程上下文的一组结构。线程上下文包括线程的一组机器寄存器、内核堆栈、线程环境块和线程进程地址空间中的用户堆栈。线程也可以有自己的安全上下文，用于模拟客户端。
在这里的msdn上找到这个：关于进程和线程
Microsoft Windows supports preemptive multitasking, which creates the effect of simultaneous execution of multiple threads from multiple processes. On a multiprocessor computer, the system can simultaneously execute as many threads as there are processors on the computer.
过程：
- 程序的执行实例称为进程。
- 有些操作系统使用术语"任务"来指正在执行的程序。
- 进程总是存储在主存储器中，也称为主存储器或随机存取存储器。
- 因此，过程被称为活动实体。如果机器重新启动，它就会消失。
- 多个进程可以与同一个程序相关联。
- 在多处理器系统上，可以并行执行多个进程。
- 在单处理器系统中，虽然没有实现真正的并行性，但是应用了一种进程调度算法，并且将处理器调度为一次执行一个进程，从而产生并发的假象。
- 示例：执行"计算器"程序的多个实例。每个实例都被称为一个过程。
线程：
- 线程是进程的一个子集。
- 它被称为"轻量级进程"，因为它与实际进程类似，但在进程上下文中执行，并共享内核分配给进程的相同资源。
- 通常，一个进程只有一个控制线程——一次执行一组机器指令。
- 进程也可以由多个执行线程组成，这些线程同时执行指令。
- 多线程控制可以利用多处理器系统上的真正并行性。
- 在单处理器系统中，应用了一种线程调度算法，处理器被调度为一次运行一个线程。
- 在一个进程中运行的所有线程共享相同的地址空间、文件描述符、堆栈和其他与进程相关的属性。
- 由于进程的线程共享相同的内存，因此同步进程内对共享数据的访问具有前所未有的重要性。
我从知识探索中借用了以上信息！博客。
首先，让我们看看理论方面。您需要从概念上理解流程是什么，以理解流程和线程之间的区别以及它们之间共享的内容。
我们从Tanenbaum的第2.2.2节"现代操作系统3e中的经典线程模型"中得到以下内容：
The process model is based on two independent concepts: resource
grouping and execution. Sometimes it is use-ful to separate them;
this is where threads come in....
他继续说：
One way of looking at a process is that it is a way to
group related resources together. A process has an address space
containing program text and data, as well as other resources. These
resource may include open files, child processes, pending alarms,
signal handlers, accounting information, and more. By putting them
together in the form of a process, they can be managed more easily.
The other concept a process has is a thread of execution, usually
shortened to just thread. The thread has a program counter that keeps
track of which instruc-tion to execute next. It has registers, which
hold its current working variables. It has a stack, which contains the
execution history, with one frame for each proce-dure called but not
yet returned from. Although a thread must execute in some process, the
thread and its process are different concepts and can be treated
sepa-rately. Processes are used to group resources together; threads
are the entities scheduled for execution on the CPU.
下一步，他提供了下表：
1 2 3 4 5 6 7 8 9 | 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 | |
让我们来处理硬件多线程问题。传统上，CPU支持单个执行线程，通过单个程序计数器和一组寄存器来维护线程的状态。但是如果有缓存丢失怎么办？从主内存中获取数据需要很长时间，而当这发生时，CPU只是处于空闲状态。所以有人想基本上有两组线程状态(PC+寄存器)，这样另一个线程(可能在同一进程中，也可能在不同进程中)可以在另一个线程等待主内存时完成工作。这个概念有多个名称和实现，例如超线程和同时多线程(简称SMT)。
现在让我们看看软件方面。基本上有三种方法可以在软件方面实现线程。
实现线程所需要的只是保存CPU状态和维护多个堆栈的能力，在许多情况下，这可以在用户空间中完成。用户空间线程的优点是超快速的线程切换，因为您不必陷入内核中，并且能够按您喜欢的方式调度线程。最大的缺点是无法进行阻塞I/O(这将阻塞整个进程及其所有用户线程)，这是我们首先使用线程的一个重要原因。使用线程阻塞I/O在许多情况下大大简化了程序设计。
内核线程的优点是除了将所有调度问题留给操作系统之外，还能够使用阻塞I/O。但每个线程切换都需要捕获到内核中，这可能相对较慢。但是，如果您因为I/O阻塞而切换线程，这并不是真正的问题，因为I/O操作可能已经将您困在内核中了。
另一种方法是将这两种方法结合起来，使用多个内核线程，每个线程都有多个用户线程。
回到术语问题，你可以看到一个过程和一个执行线程是两个不同的概念，你选择使用哪个术语取决于你在说什么。关于"轻量级过程"这个术语，我个人并不认为它的意义所在，因为它并不能真正传达正在发生的事情以及术语"执行的线程"。
关于并发编程的更多解释
进程具有独立的执行环境。进程通常具有一组完整的、私有的基本运行时资源；特别是，每个进程都有自己的内存空间。
线程存在于进程中-每个进程至少有一个。线程共享进程的资源，包括内存和打开的文件。这有助于有效但有潜在问题的沟通。
记住普通人，
在计算机上，打开Microsoft Word和Web浏览器。我们称之为这两个过程。
在Microsoft Word中，您键入一些内容，它将自动保存。现在，您将看到编辑和保存是并行进行的——在一个线程上进行编辑，在另一个线程上进行保存。
An application consists of one or more processes. A process, in the simplest terms, is an executing program. One or more threads run in the context of the process. A thread is the basic unit to which the operating system allocates processor time. A thread can execute any part of the process code, including parts currently being executed by another thread. A fiber is a unit of execution that must be manually scheduled by the application. Fibers run in the context of the threads that schedule them.
从这里被偷的。
进程是代码、内存、数据和其他资源的集合。线程是在进程范围内执行的代码序列。您可以(通常)在同一进程中同时执行多个线程。
- 每个进程都是一个线程(主线程)。
- 但每一条线都不是一个过程。它是流程的一部分(实体)。
流程和线程的实际示例这将为您提供有关线程和进程的基本概念
我从斯科特·兰厄姆的回答中借用了上述信息-谢谢。
型
过程：
百万千克1过程是一个很重的过程。百万千克1百万千克1进程是一个单独的程序，它有单独的内存、数据、资源等。百万千克1百万千克1进程是使用fork()方法创建的。百万千克1百万千克1进程之间的上下文切换非常耗时。百万千克1
例子：比如，打开任何浏览器(Mozilla、Chrome、IE)。此时，新进程将开始执行。
线程：
百万千克1线程是轻量级的进程。线程被捆绑在进程内。百万千克1百万千克1线程具有共享内存、数据、资源、文件等。百万千克1百万千克1线程是使用clone()方法创建的。百万千克1百万千克1线程之间的上下文切换不像进程那样耗时。百万千克1
例子：在浏览器中打开多个选项卡。
进程和线程都是独立的执行序列。典型的区别是(同一进程的)线程在共享内存空间中运行，而进程在单独的内存空间中运行。
过程
是正在执行的程序。它有文本部分，即程序代码、当前活动(由程序计数器的值和处理器寄存器的内容表示)。它还包括包含临时数据(如函数参数、返回地址和局部变量)的过程堆栈，以及包含全局变量的数据部分。进程还可以包括堆，堆是在进程运行时动态分配的内存。
螺纹
线程是CPU利用率的基本单位；它包括线程ID、程序计数器、寄存器集和堆栈。它与属于同一进程的其他线程共享其代码段、数据段和其他操作系统资源，如打开的文件和信号。
--从操作系统中提取
线程和进程都是操作系统资源分配的原子单位(即，有一个并发模型描述了CPU时间如何在它们之间划分，以及拥有其他操作系统资源的模型)。不同之处在于：
- 共享资源(线程根据定义共享内存，除了堆栈和局部变量外，它们不拥有任何东西；进程也可以共享内存，但有一个独立的机制，由操作系统维护)
- 分配空间(进程的内核空间与线程的用户空间)
上面的greg hewgill对于"过程"这个词的erlang含义是正确的，这里有一个讨论，为什么erlang可以做轻量级的过程。
试图回答有关Java世界的问题。
进程是程序的执行，但线程是进程中的单个执行序列。一个进程可以包含多个线程。线程有时被称为轻量级进程。
例如：
例1：JVM在单个进程中运行，而JVM中的线程共享属于该进程的堆。这就是为什么几个线程可以访问同一个对象的原因。线程共享堆并有自己的堆栈空间。这就是一个线程对方法及其局部变量的调用如何使线程免受其他线程的攻击。但是堆不是线程安全的，必须同步才能保证线程安全。
例2：程序可能无法通过读取击键来绘制图片。程序必须充分注意键盘输入，如果一次无法处理多个事件，则会导致故障。这个问题的理想解决方案是同时无缝地执行一个程序的两个或多个部分。线程允许我们这样做。这里画图是一个过程，读键是一个子过程(线程)。
线程和进程之间的区别？
进程是应用程序的执行实例，线程是进程内的执行路径。另外，一个进程可以包含多个线程。需要注意的是，一个线程可以做一个进程可以做的任何事情。但是，由于一个进程可以由多个线程组成，因此一个线程可以被视为"轻量级"进程。因此，一个线程和一个进程之间的本质区别是每个线程用来完成的工作。线程用于小任务，而进程用于更重的任务——基本上是应用程序的执行。
线程和进程之间的另一个区别是，同一进程中的线程共享相同的地址空间，而不同的进程不共享。这允许线程对相同的数据结构和变量进行读写操作，也有助于线程之间的通信。进程之间的通信——也称为IPC，或进程间通信——非常困难且资源密集。
Here’s a summary of the differences between threads and processes:
线程比进程更容易创建，因为它们不需要单独的地址空间。
多线程需要仔细编程，因为线程共享只能由一个线程修改的数据结构一次。与线程不同，进程不共享相同的地址空间。
线程被认为是轻量级的，因为它们使用远资源比流程少。
过程彼此独立。线程，因为它们共享相同的地址空间是相互依赖的，因此请注意必须采取这样的措施，不同的线程不会相互踩在一起。这实际上是上述2的另一种表述方式。
进程可以由多个线程组成。
lkml.iu.edu http：/ / / / / / hypermail Linux内核0191.html 9608号
Linus Torvalds ([email protected])
Ok.
Tue, 6 Aug 1996 12:47:31 +0300 (EET DST)
Ok.
Messages sorted by: [ date ][ thread ][ subject ][ author ]
Ok.
Next message: Bernd P. Ziller:"Re: Oops in get_hash_table"
Ok.
Previous message: Linus Torvalds:"Re: I/O request ordering"
Ok.
On Mon, 5 Aug 1996, Peter P. Eiserloh wrote:
Ok.
We need to keep a clear the concept of threads. Too many people
seem to confuse a thread with a process. The following discussion
does not reflect the current state of linux, but rather is an
attempt to stay at a high level discussion.Ok.
NO！
没有理由认为"线程"和"过程"是单独的实体。这是它以前做的，但我个人认为这是一个错误的认为，专业的方式。唯一的历史的原因，认为是合理的方式。
这是真的我只是一个线程和进程的上下文的东西：A"执行"。试图区分不同情况下的只是人工自限。
a"，那些所谓的上下文执行"是一个conglomerate COE一切是那州州立COE。这样的CPU包括状态寄存器等)、状态(MMU的页映射)，使用状态(的UID和GID)"中的各种通信信号(打开文件"处理程序等)。传统上，"线程"之间的差异A和a"流程"已提供一个线程的CPU状态(+是安切洛蒂其他一些小国家)，而所有其他的上下文是从流程。然而，这很分水岭上完全单向(State of the Coe说，有没有什么是它的正确的方式来做。自己的极限认为孩子只是平原愚蠢的图像。
关于这个事情的方式和Linux的工作方式是我想要的东西)这是没有找到的东西作为一个"过程"或"线程"。有只有在totality COE(所谓的"任务"的Linux)。不同科的股部分的上下文可以与对方，和一个子集)这是传统的共享的"线程"/"过程"的设置，但这我真的只是一个湖泊作为重要的(它的子集的子集，但这是不是设计的重要性，但在准则：我们明显要运行的线程上协调标准的Linux程序太)。
短：不要在线程的设计/过程的思维方式。酒店COE应该在内核设计的思维方式，然后在pthreads库的CAN接口到用户线程出口有限公司谁想看大学COE使用这样做。
就像一个例子，当你认为coe是与线程/进程相反：好的。
- 你可以做一个外部的"cd"程序，这在UNIX和/或进程/线程中是传统上不可能实现的(愚蠢的例子，但是您可以拥有这些类型的"模块"，这些模块不仅限于传统的Unix/Threads设置)。答：
克隆(克隆vm克隆fs)；好的。
子级：Execve("外部CD")；好的。
/*"execve()"将解除虚拟机的关联，因此使用克隆vm是为了加快克隆的速度*/好的。
- 您可以自然地执行"vfork()"(它满足最小的内核支持，但这种支持完全符合CUA的思维方式)：
克隆(clone_vm)；好的。
子：继续运行，最终执行()。好的。
母亲：等着执行好的。
- 你可以做外部的"IO讲道会"：
克隆(克隆文件)；好的。
子：打开文件描述符等好的。
母亲：用fd的，孩子打开的，vv。好的。
以上所有工作都是因为您没有绑定到线程/进程思维方式。例如，一个Web服务器，其中脚本作为"执行线程"完成。你不能这么做传统线程，因为传统线程总是必须共享整个地址空间，所以你必须链接你曾经的所有东西希望在Web服务器本身中执行此操作("线程"无法运行其他线程可执行文件)。好的。
将此视为"执行环境"问题，而不是任务现在可以选择执行外部程序(=分隔如果他们愿意，或者他们可以示例与父级共享除文件之外的所有内容描述符(这样子"线程"就可以在没有需要担心的家长：当子线程会退出，并且不会耗尽父线程中的fd)。好的。
例如，想象一个线程"inetd"。你想要低开销fork+exec，因此使用Linux方式，您可以不使用"fork()"您可以编写一个多线程inetd，其中每个线程都是用只需克隆vm(共享地址空间，但不共享文件描述符等)。如果是外部服务(rlogin，例如)，或者它可能是内部inetd服务之一(echo，timeofday)在这种情况下，它只会做它的事情，然后退出。好的。
你不能用"thread"/"process"这样做。好的。
莱纳斯好的。< /块引用>好啊。
下面是我从代码项目的一篇文章中得到的信息。我想它清楚地解释了所有需要的东西。
A thread is another mechanism for splitting the workload into separate
execution streams. A thread is lighter weight than a process. This
means, it offers less flexibility than a full blown process, but can
be initiated faster because there is less for the Operating System to
set up. When a program consists of two or more threads, all the
threads share a single memory space. Processes are given separate address spaces.
all the threads share a single heap. But each thread is given its own stack.从面试官的角度来看，基本上我只想听到三件主要的事情，除了一些显而易见的事情，比如一个过程可以有多个线程：
线程共享相同的内存空间，这意味着线程可以从其他线程内存访问内存。进程通常不能。 资源。资源(内存、句柄、套接字等)在进程终止时释放，而不是线程终止时释放。 安全性。进程具有固定的安全令牌。另一方面，线程可以模拟不同的用户/令牌。 如果你想要更多，斯科特·兰厄姆的回答几乎涵盖了一切。所有这些都是从操作系统的角度来看的。不同的语言可以实现不同的概念，比如任务、轻量级线程等等，但它们只是使用线程(Windows上的光纤)的方法。没有硬件和软件线程。有硬件和软件异常和中断，或者用户模式和内核线程。
过程：正在执行的程序称为过程
线程：线程是根据"一个与另一个"的概念与程序的另一部分一起执行的功能，因此线程是进程的一部分。
线程在共享内存空间中运行，但进程在单独的内存空间中运行 线程是一个轻量的过程，但过程是一个重量的过程。 线程是进程的子类型。
基本上，线程是没有进程线程的进程的一部分，线程将无法工作。 线程是轻量级的，而进程是重量级的。 进程之间的通信需要一些时间，而线程需要较少的时间。 线程可以共享相同的内存区域，而进程是分开的。 来自嵌入式世界，我想补充一点，进程的概念只存在于"大"处理器(台式CPU、ARM Cortex A-9)中，这些处理器具有MMU(内存管理单元)和支持使用MMU的操作系统(如Linux)。对于小型/老式处理器和微控制器以及小型RTOS操作系统(实时操作系统)，如Freertos，没有MMU支持，因此没有进程，只有线程。
线程可以访问彼此的内存，并且它们是由操作系统以交错方式安排的，因此它们看起来是并行运行的(或者使用真正并行运行的多核)。
另一方面，进程则生活在由MMU提供和保护的私有虚拟内存沙盒中。这很方便，因为它可以：
防止小车进程破坏整个系统。 通过使其他进程数据不可见和遥不可及。进程内的实际工作由一个或多个线程负责。 在用包含多线程的Python(解释语言)构建算法时，我惊讶地发现，与我以前构建的顺序算法相比，执行时间没有任何提高。为了理解这个结果的原因，我做了一些阅读，相信我学到的内容提供了一个有趣的上下文，从中可以更好地理解多线程和多进程之间的区别。
多核系统可以运行多个执行线程，因此Python应该支持多线程。但python不是编译语言，而是解释语言1。这意味着必须解释程序才能运行，并且在程序开始执行之前，解释程序不知道该程序。然而，它所知道的是Python的规则，然后动态地应用这些规则。然后，Python中的优化必须主要是解释器本身的优化，而不是要运行的代码。这与编译语言(如C++)形成对比，并对Python中的多线程产生了影响。具体来说，python使用全局解释器锁来管理多线程。
另一方面，编译语言是编译好的。程序是"完全"处理的，首先根据其语法定义进行解释，然后映射到语言不可知的中间表示，最后链接到可执行代码中。这个过程允许对代码进行高度优化，因为编译时代码都是可用的。在创建可执行文件时定义了各种程序交互和关系，并且可以做出关于优化的可靠决策。
在现代环境中，python的解释器必须允许多线程，这必须是安全和高效的。这就是解释语言和编译语言之间的区别进入画面的地方。解释器不得干扰来自不同线程的内部共享数据，同时优化使用处理器进行计算。
正如在前面的文章中所指出的，进程和线程都是独立的顺序执行，主要的区别在于内存在进程的多个线程之间共享，而进程隔离它们的内存空间。
在python中，通过全局解释器锁防止不同线程同时访问数据。它要求在任何Python程序中，任何时候只能执行一个线程。另一方面，可以运行多个进程，因为每个进程的内存都与任何其他进程隔离，并且进程可以在多个核心上运行。
1 Donald Knuth对计算机编程技术中的解释性程序有很好的解释：基本算法。
型对于那些更愿意通过可视化学习的人来说，这里有一个我创建的方便的图表来解释过程和线程。我使用了来自msdn的关于进程和线程的信息
。
尝试从Linux内核的操作系统视图回答它
程序在启动到内存中时会变成一个进程。一个进程有自己的地址空间，这意味着在内存中有不同的段，例如用于存储编译代码的.text段，.bss用于存储未初始化的静态或全局变量等。每个进程都有自己的程序计数器和用户spcae堆栈。在内核内部，每个进程都有自己的内核堆栈(由于安全问题与用户空间堆栈分离)和一个名为
task_struct 的结构，通常被抽象为进程控制块，存储与进程有关的所有信息，如优先级、状态(以及大量其他块)。一个进程可以有多个执行线程。对于线程，它们驻留在一个进程中，并与其他资源共享父进程的地址空间，这些资源可以在线程创建期间传递，例如文件系统资源、共享挂起的信号、共享数据(变量和指令)，因此使线程更轻，从而允许更快的上下文切换。在内核内部，每个线程都有自己的内核堆栈以及定义线程的
task_struct 结构。因此，内核将同一进程的线程视为不同的实体，并且可以自己调度。同一进程中的线程共享一个称为线程组ID(tgid 的公共ID)，并且它们有一个称为进程ID(pid 的唯一ID)。同一进程中的线程共享内存，但每个线程都有自己的堆栈和寄存器，并且线程将特定于线程的数据存储在堆中。线程从不独立执行，因此与进程间通信相比，线程间通信要快得多。
进程从不共享相同的内存。当子进程创建时，它会复制父进程的内存位置。进程通信是通过使用管道、共享内存和消息解析来完成的。线程之间的上下文切换非常缓慢。
它们几乎一样…但关键的区别在于线程是轻量级的，而在上下文切换、工作负载等方面，进程是很重的。
型到目前为止，我找到的最好的答案是迈克尔·克里斯克的"Linux编程接口"：
In modern UNIX implementations, each process can have multiple threads
of execution. One way of envisaging threads is as a set of processes
that share the same virtual memory, as well as a range of other
attributes. Each thread is executing the same program code and shares
the same data area and heap. However, each thread has it own stack
containing local variables and function call linkage information. [LPI 2.12]号
这本书是一个非常清晰的来源；Julia Evans在本文中提到了它在清理Linux组如何真正工作方面的帮助。
最佳答案
过程：
过程基本上是一个正在执行的程序。它是一个活动实体。有些操作系统使用术语"任务"来指正在执行的程序。进程总是存储在主存储器中，也称为主存储器或随机存取存储器。因此，过程被称为活动实体。如果机器重新启动，它就会消失。多个进程可以与同一个程序相关联。在多处理器系统上，可以并行执行多个进程。在单处理器系统中，虽然没有实现真正的并行性，但是应用了一种进程调度算法，并且将处理器调度为一次执行一个进程，从而产生并发的假象。示例：执行"计算器"程序的多个实例。每个实例都被称为一个过程。
线程：
线程是进程的一个子集。它被称为"轻量级进程"，因为它与实际进程类似，但在进程上下文中执行，并共享内核分配给进程的相同资源。通常，一个进程只有一个控制线程——一次执行一组机器指令。进程也可以由多个执行线程组成，这些线程同时执行指令。多线程控制可以利用多处理器系统上的真正并行性。在单处理器系统中，应用了一种线程调度算法，处理器被调度为一次运行一个线程。在一个进程中运行的所有线程共享相同的地址空间、文件描述符、堆栈和其他与进程相关的属性。由于进程的线程共享相同的内存，因此将对共享数据的访问与进程同步具有前所未有的重要性。
参考https://practice.geeksforgeks.org/problems/difference-between-process-and-thread
将流程视为一个所有权单元或任务所需的资源。进程可以有内存空间、特定的输入/输出、特定的文件和优先级等资源。
线程是一个可调度的执行单元，或者简单地说，是一系列指令的执行进度。
示例1:JVM在单个进程中运行，而JVM中的线程共享属于该进程的堆。这就是为什么几个线程可以访问同一个对象的原因。线程共享堆并有自己的堆栈空间。这就是一个线程对方法及其局部变量的调用如何使线程免受其他线程的攻击。但是堆不是线程安全的，必须同步才能保证线程安全。
型工艺和螺纹的区别如下：
百万千克1进程是一个正在执行的程序实例，而线程是进程的最小单元。百万千克1百万千克1进程可以划分为多个线程，而线程不能划分。百万千克1百万千克1进程可以被视为任务，而线程可以被视为任务轻量级进程。百万千克1百万千克1进程分配单独的内存空间，而线程分配共享内存空间。百万千克1百万千克1进程由操作系统维护，而线程由程序员维护。百万千克1
型
唉，作为一名正在上操作系统课程的本科生，我已经仔细阅读了几乎所有的答案，但我目前还不能完全理解这两个概念。我的意思是，大多数人从一些操作系统书籍中读到不同之处，即线程能够访问事务单元中的全局变量，因为它们利用进程的地址空间。然而，新的问题出现了，为什么会有进程，我们知道线程已经是更轻量的vis-vis进程了。让我们用从前面的答案中摘录的图像来看下面的示例，
我们有3个线程同时处理Word文档，例如libre office。第一种方法是在单词拼写错误时加下划线进行拼写检查。第二个从键盘上取下并打印字母。最后一种方法是在短时间内保存文档，以防出错时丢失所处理的文档。在这种情况下，3个线程不能是3个进程，因为它们共享一个公共内存，即进程的地址空间，因此所有线程都可以访问正在编辑的文档。所以，这条路就是文字文件，还有两台推土机，虽然其中一台图像上没有螺纹，但它们都是螺纹。
型来自Erlang编程(2009)：Erlang并发性快速且可扩展。它的进程是轻量级的，因为Erlang虚拟机不会为每个创建的进程创建OS线程。它们是在虚拟机中创建、调度和处理的，独立于底层操作系统。
Erlang实现了一个抢占式调度程序，它允许每个进程运行一段设定的时间，而不会阻塞系统线程太长，这会给每个进程一些CPU时间来执行。如果我没有弄错，系统线程的数量取决于核心的数量，如果负载变得不均匀，进程可以从一个线程中删除并移动到另一个线程中，这都由Erlang调度程序处理。
。