进程和线程有什么区别?

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

我不确定您可能指的是什么“硬件”和“软件”线程。线程是操作环境特性,而不是CPU特性(尽管CPU通常具有使线程高效的操作)。

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

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

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

在这里的msdn上找到这个:
About Processes and Threads

Microsoft Windows支持先发制人的多任务处理,这就产生了从多个进程同时执行多个线程的效果。在多处理器计算机上,系统可以同时执行与计算机上的处理器相同数量的线程。

过程:

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

线程:

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

我从 Knowledge Quest! blog .

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

我们有以下部分 2.2.2经典螺纹模型 在里面 Modern Operating Systems 3e 塔嫩鲍姆:

过程模型基于两个独立的概念:资源 分组和执行。有时,分离它们是很有用的; 这就是线程进入的地方……

他继续说:

查看流程的一种方法是 将相关资源分组在一起。进程有地址空间 包含程序文本和数据以及其他资源。这些 资源可能包括打开的文件、子进程、挂起的警报, 信号处理程序、记帐信息等。放他们 它们以一个过程的形式组合在一起,可以更容易地管理。 流程的另一个概念是执行线程,通常 缩短到只穿线。线程有一个程序计数器, 跟踪下一步要执行的指令。它有寄存器, 保持其当前工作变量。它有一个堆栈,其中包含 执行历史记录,每个过程调用一个帧,但不调用 但从返回。虽然线程必须在某些进程中执行,但是 线程及其过程是不同的概念,可以处理 分别地。进程用于将资源分组在一起;线程 是否计划在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+寄存器),这样另一个线程(可能在同一进程中,也可能在不同进程中)可以在另一个线程等待主内存时完成工作。这个概念有多个名称和实现,例如超线程和 Simultaneous Multithreading (简称SMT)。

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

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

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

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

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

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

关于并发编程的更多解释

1. 进程具有独立的执行环境。进程通常具有一组完整的、私有的基本运行时资源;特别是,每个进程都有自己的内存空间。

2. 线程存在于一个进程中,每个进程至少有一个线程。线程共享进程的资源,包括内存和打开的文件。这有助于有效但有潜在问题的沟通。

记住普通人,

在计算机上,打开Microsoft Word和Web浏览器。我们叫这两个 过程 .

在Microsoft Word中,您键入一些内容,它将自动保存。现在,您将看到编辑和保存是并行进行的——在一个线程上进行编辑,在另一个线程上进行保存。

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

被盗 here .

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

• 每个进程都是一个线程(主线程)。
• 但每一条线都不是一个过程。它是流程的一部分(实体)。

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

我从斯科特·兰厄姆的回答中借用了上述信息 -谢谢

过程:

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

例子:
比如,打开任何浏览器(Mozilla、Chrome、IE)。此时,新进程将开始执行。

线程:

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

例子:
在浏览器中打开多个选项卡。

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

过程

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

螺纹

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

--从操作系统中提取

线程和进程都是操作系统资源分配的原子单位(即,有一个并发模型描述了CPU时间如何在它们之间划分,以及拥有其他操作系统资源的模型)。不同之处在于:

• 共享资源(线程根据定义共享内存,除了堆栈和局部变量外,它们不拥有任何东西;进程也可以共享内存,但有一个独立的机制,由操作系统维护)
• 分配空间(进程的内核空间与线程的用户空间)

上面的格雷格·休吉尔对“过程”这个词的二郎含义是正确的,并且 here 有人讨论了Erlang为什么可以做轻量级的流程。

试图回答有关Java世界的问题。

进程是程序的执行,但线程是进程中的单个执行序列。一个进程可以包含多个线程。线程有时称为 轻量级过程 .

例如:

例1: JVM在单个进程中运行,而JVM中的线程共享属于该进程的堆。这就是为什么几个线程可以访问同一个对象的原因。线程共享堆并有自己的堆栈空间。这就是一个线程对一个方法及其局部变量的调用如何使线程免受其他线程的攻击。但是堆不是线程安全的,必须同步才能保证线程安全。

例2: 程序可能无法通过读取击键来绘制图片。程序必须充分注意键盘输入,如果一次无法处理多个事件,则会导致故障。这个问题的理想解决方案是同时无缝地执行一个程序的两个或多个部分。线程允许我们这样做。这里画图是一个过程,读键是一个子过程(线程)。

Difference between Thread and Process?

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

线程和进程之间的另一个区别是,同一进程中的线程共享相同的地址空间,而不同的进程不共享。这使得线程可以读取和写入相同的数据结构和变量,也有助于线程之间的通信。过程间通信,也称为IPC,或过程间通信,非常困难且资源密集。

这里是线程和进程之间差异的摘要:

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

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

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

4. 过程彼此独立。线程,因为它们 共享相同的地址空间是相互依赖的,因此请注意 必须采取这样的措施,不同的线程不会相互踩在一起。
   这实际上是上述2的另一种表述方式。

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

从面试官的角度来看,基本上我只想听到三件主要的事情,除了显而易见的事情,比如一个过程可以有多个线程:

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

如果你想要更多,斯科特·兰厄姆的回答几乎涵盖了一切。 所有这些都是从操作系统的角度来看的。不同的语言可以实现不同的概念,如任务、轻量级线程等等,但它们只是使用线程(Windows上的光纤)的方法。 没有硬件和软件线程。有硬件和软件 例外情况 和 中断 或用户模式和内核 螺纹 .

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

线程是将工作负载拆分为单独的另一种机制。 执行流。线比过程轻。这个 也就是说,它提供的灵活性不如全面的流程,但可以 由于操作系统的 设置。当一个程序由两个或多个线程组成时,所有 线程共享一个内存空间。进程被赋予单独的地址空间。 所有线程共享一个堆。但是每个线程都有自己的堆栈。

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

莱纳斯·托瓦尔兹(torvalds@cs.helsinki.fi)

1996年8月6日星期二12:47:31+0300(EET DST)

邮件排序依据:【日期】【线程】【主题】【作者】

下一条消息:bernd p.ziller:“re:oops in get_hash_table”

上一条消息:Linus Torvalds:“回复:I/O请求订购”

1996年8月5日,周一,彼得P.艾瑟洛写道:

我们需要清楚地了解线程的概念。太多人 似乎把线程和进程混淆了。以下讨论 不反映Linux的当前状态,而是 尝试保持高层讨论。

不!

没有理由认为“线程”和“进程”是 单独的实体。这是传统的做法,但我 我个人认为这样想是一个重大错误。唯一 这样想的理由是历史包袱。

线程和进程实际上只是一件事:一个 执行“。试图人为地区分不同的情况只是 自限性。

一个“执行环境”,这里称为COE,只是一个集团 在该COE的所有状态中,该状态包括CPU之类的东西 状态(寄存器等)、MMU状态(页映射)、权限状态 (uid、gid)和各种“通信状态”(打开文件、信号 搬运工人等)传统上,“线程”和 “进程”主要是线程有CPU状态(可能是 其他一些最小状态),而所有其他上下文都来自 过程。不过,这只是 一 划分coe的总状态的方法,没有什么能说明这是正确的方法。限制你自己 对那种形象来说简直是愚蠢透顶。

Linux思考这个问题的方式(以及我希望事情工作的方式)是 那里 是 没有“进程”或“线程”这样的东西。有 只有COE的总量(Linux称为“任务”)。不同的COE 可以彼此共享部分上下文,并且 子集 属于 共享是传统的“线程”/“进程”设置,但是 应该只被看作是一个子集(它是一个重要的子集,但是 这种重要性不是来自设计,而是来自标准:我们显然 希望在Linux上运行符合标准的线程程序 太)。

简而言之:不要围绕线程/流程的思维方式进行设计。这个 内核的设计应该围绕COE的思维方式,然后 线程 图书馆 可以将受限pthreads接口导出到用户 谁想用这种方式来看待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”这样做。

莱纳斯

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

过程 :正在执行的程序称为进程

螺纹 :thread是一种功能,根据“一个与另一个”的概念与程序的另一部分一起执行,因此thread是进程的一部分。

来自嵌入式世界,我想补充一点,流程的概念只存在于“大”处理器中( 台式CPU,ARM Cortex A-9 )具有MMU(内存管理单元)和支持使用MMU的操作系统(如 Linux )带小型/老式处理器和微控制器和小型RTOS操作系统( 实时操作系统 )例如freertos,没有MMU支持,因此没有进程,只有线程。

螺纹 可以访问彼此的内存,并且它们是由操作系统以交错方式安排的,因此它们看起来是并行运行的(或者使用真正并行运行的多核)。

过程 另一方面,生活在由MMU提供和保护的虚拟内存的私人沙盒中。这很方便,因为它可以:

1. 防止小车进程破坏整个系统。
2. 通过使其他进程数据不可见和 遥不可及。 进程内的实际工作由一个或多个线程负责。

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

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

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

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

在现代环境中,python的解释器必须允许多线程,这必须是安全和高效的。这就是解释语言和编译语言之间的区别进入画面的地方。解释器不得干扰来自不同线程的内部共享数据,同时优化使用处理器进行计算。

正如在前面的文章中所指出的,进程和线程都是独立的顺序执行,主要的区别在于内存在进程的多个线程之间共享,而进程隔离它们的内存空间。

在python中,通过全局解释器锁防止不同线程同时访问数据。它要求在任何Python程序中,任何时候只能执行一个线程。另一方面,可以运行多个进程,因为每个进程的内存与任何其他进程都是独立的,并且进程可以在多个核心上运行。

^一 唐纳德·克努斯对计算机程序设计艺术中的解释程序有很好的解释:基本算法。

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

程序在启动到内存中时会变成一个进程。一个进程有自己的地址空间,这意味着在内存中有不同的段,例如用于存储编译代码的.text段,.bss用于存储未初始化的静态或全局变量等。每个进程都有自己的程序计数器和用户spcae。 堆栈 . 在内核中,每个进程都有自己的内核堆栈(由于安全问题,它与用户空间堆栈分离)和一个名为 task_struct 它通常被抽象为过程控制块,存储与过程有关的所有信息,如优先级、状态(以及大量其他块)。一个进程可以有多个执行线程。

对于线程,它们驻留在一个进程中,并与其他资源共享父进程的地址空间,这些资源可以在线程创建期间传递,例如文件系统资源、共享挂起的信号、共享数据(变量和指令),因此使线程更轻,从而允许更快的上下文切换。在内核中,每个线程都有自己的内核堆栈以及 任务结构 定义线程的结构。因此,内核将同一进程的线程视为不同的实体,并且可以自己调度。同一进程中的线程共享一个称为线程组ID的公共ID( tgid )也有一个唯一的ID,称为进程ID( pid )

对于那些更愿意通过可视化学习的人来说,这里有一个我创建的方便的图表来解释过程和线程。
我使用了来自msdn的信息- About Processes and Threads

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

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

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

最佳答案

过程:

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

线程:

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

参考文献 https://practice.geeksforgeeks.org/problems/difference-between-process-and-thread

示例1:JVM在单个进程中运行,而JVM中的线程共享属于该进程的堆。这就是为什么几个线程可以访问同一个对象的原因。线程共享堆并有自己的堆栈空间。这就是一个线程对一个方法及其局部变量的调用如何使线程免受其他线程的攻击。但是堆不是线程安全的,必须同步才能保证线程安全。

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

线程是一个可调度的执行单元,或者简单地说,是一系列指令的执行进度。

工艺和螺纹的区别如下:

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