突然资讯网
首页 >> 科技 >> 正文

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程

日期:2021-01-19 23:10:23 来源:互联网 编辑:小优 阅读人数:647

看看这样几个题应该怎么回答:

进程和线程是什么

进程和线程有什么区别

为什么有了进程又出现线程

内核态和用户态有啥不同

协程有什么特点

一系列的问题伴随到学习,工作的各个阶段,这些问题确实不怎么好回答。除非你真的理解到它的底层原理,否则很容易就把自己套进去。

那么今天我们一起来看看这些问题都是怎么产生的,为什么总是会问这些题,开始吧。

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图1)

进程和线程

进程,平时我们打开一个播放器,开一个记事本,这些都是应用程序,一个软件的执行副本,这就是进程。从操作层面而言,进程是分配资源的基本单位,线程在很长时间被称为轻量级的进程,是程序执行的基本单位

这样看来一个分配资源的基本单位,一个是程序执行的基本单元。以前面试的时候,我经常也就这样背给面试官了。当自己成为了面试官才发现这些孩子答案为啥都是这个,原来网上大部分的资料也就说了这些呢。直接这样死记硬背当然不行,让我们回到最初的计算机时代。

最初的计算机时代是什么样子呢?

那个时代呀,程序员会将写好的程序放入闪存中,插入到机器里,通过电能推动芯片计算,那么芯片从闪存中取出指令,执行下一条执行,一旦闪存中的执行执行完了,计算机就要关机了

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图2)

闪存时代

这在早期叫做单任务模型,也叫做作业(Job)

随着人们的需求越来越多,生活的多元化,慢慢出现了办公,聊天,游戏等,这个时候不得不在同一台计算机中来回的切换,人们就想要不通过线程和进程来处理这个问题。

那是怎么处理的方式?

比如说一个游戏,启动后为一个进程,但是一个游戏场面的呈现需要图形的渲染,联网,这些操作不能相互的阻塞,如果阻塞了,卡起就很难受,总觉得这游戏怎么这么 low。我们希望它们能同时的运行,所以将其各个部分设计为线程,这就出现了一个进程有多个线程。

既然一个进程有多个线程,这个资源分配如何处理?

启动一个游戏,首先需要存储这些游戏参数,所以需要内存资源。当进行攻击等动作时候,发出的各种动作指令需要计算,所以需要计算资源 CPU,还需要需要存储一些文件,所以还需要文件资源。由于早期的 OS 没有线程的概念,所以让各个进程采用分时的技术交替执行,通过管道等技术让各个进程进行通信。

这样看上去比较完美了,启动一个游戏后出来这么多进程,那么能不能启动游戏后,在这个进程下面安排一种技术,让其仅仅分配 CPU 资源呢,这就出现了线程。

这个线程如何分配的?

线程概念被提出来以后,因为只分配了 CPU 计算资源,所以也叫做轻量级的进程。

通过操作来调度线程,也就是说操作创建进程后,“牵个线”进程的入口程序被放在主线程中,看起来就感觉是操作在调度进程,实际上调度的是进程中线程,这种作直接调度的线程叫做内核级线程。

内核级别线程和用户级线程

既然有内核级别线程,当然有用户级线程,相当于操作调度线程,主线程通过程序的方式实现子线程,这就是用户级线程,典型的即 Linux 中的 Phread API。既然说到内核态和用户态,我们来看看两者有什么作用。

用户态线程

它完全是在用户空间创建,对于操作而言是不知情的,用户级线程的优势如下:

切换成本低:用户空间自己维护,不用走操作的调度

开销小:创建和销毁不用调用,调用所造成的上下文切换下文会讲解

用户态线程有什么缺点?

与内核沟通成本大:因为这种线程大部分时间在用户空间,如果进行 IO 操作,很难利用内核的优势,且需要频繁的用户态和内核态的切换

线程之间的协作麻烦:想象两个线程 A 和 B 需要通信,通信通常会涉及到 IO 操作,IO 操作涉及到调用,调用又要发生用户态和内核套的切换成本,难

操作无法针对线程的调度进行优化:如果一个进程的用户态线程阻塞了操作无法及时的发现和处理阻塞问题,它不会切换其他线程从而造成浪费

内核态线程

内核态线程执行在内核态,一般通过调用创造一个内核级线程,那么有哪些优点?

操作级优化:内核中的线程

即使

执行 IO 操作也不需要进行调用,一个内核阻塞可以让其他立即执行

充分利用多核优势:内核权限足够高,可以在多个 CPU 核心执行内核线程

内核级线程有什么缺点?

创建成本比较高:创建的时候需要使用调用即切换到内核态

切换成本高:切换的时候需要进行内核操作

扩展性差:因为一个内核,坑位有限,不可能数量太多

用户态线程和内核态线程的映射关系是怎样的呢?

上面谈到用户态线程和内核态线程都有缺点,用户态线程创建成本低,不可以利用多核,而内核态线程创建成本高,虽可以利用多核,但是切换速度慢。所以,通常都会在内核中预留一些线程并反复使用这些线程,至此出现了以下几种映射关系

用户态和内核态映射之一--多对一

内核线程的创建成本既然高,那么我们就是多个用户态进程的多线程复用一个内核态线程,可是这样线程不能并发,所以此模型用户很少。

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图3)

用户态线程与内核态线程多对一

用户态和内核态映射之二--一对一

让每个用户态线程分配一个单独的内核态线程,每个用户态线程通过调用创建一个绑定的内核线程,这种模型能够并发执行,充分利用多核的优势,出名的 Windows NT 即采用这种模型,但是如果线程比较多,对内核的压力就太大

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图4)

用户态线程与内核态线程一对一

用户态和内核态映射之三--多对多

即 n 个用户态线程对应 m 个内核态线程。m 通常小于等于 n,m 通常设置为核数,这种多对多的关系减少了内核线程且完成了并发,Linux 即采用的这种模型

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图5)

用户态线程与内核态线程多对一用户态线程与内核态线程多对多

一台计算机会启动很多进程,其数量当然是大于 CPU 数量,只好让 CPU 轮流的分配给它们,让我们产生了多任务同时执行的错觉,那有没有想过这些任务执行之前,CPU 都会干啥?

CPU 既然要执行它,势必会去了解从哪里加载它,又从哪里开始运行,也就是说,需要提前将它们设置好 CPU 寄存器和程序计数器

你眼中的寄存器和程序计数器是什么?

它虽小不过威力却很大,速度很快的内存。而程序计数器用来记录正在执行指令的位置,这些 CPU 需要依赖的环境即 CPU 的上下文。上下文知道了,那么 CPU 的切换是不是就很好理解。

将前一个任务的 CPU 上下文保存下来,加载新任务的上下文到寄存器和程序计数器中,跳转到程序计数器所指向的位置。根据任务的不同又分为进程的上下文和线程的上下文。

进程的上下文

进程在用户空间运行的时候叫做用户态,陷入到内核空间叫做进程的内核态,如果用户态的进程想转变到内核态,则可以通过调用的方式完成。进程由内核调度,进程的切换发生在内核态

进程的上下文包含哪些数据?

既然进程的切换发生在内核态,那么进程的上下文不仅仅包括虚拟内存,栈,全局变量等用户空间资源,还包括了内核堆栈,寄存器等内核空间的状态

这里的保存上下文和恢复上下文也不是说免费的,需要内核在 CPU 上运行才能完成

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图6)

上下文保存

线程上下文切换

看到这里,你肯定可以脱口而出两者的区别在于线程是调度的基本单位,而进程是资源拥有的基本单位。讲白了,内核的任务调度实际上调度的是线程,进程只是为线程提供虚拟内存,全局变量等资源,所以这样理解可能更好:

进程如果只有一个线程,那么认为进程就是线程

如果进程有多个线程,那么多个线程会共享相同的虚拟内存和全局变量等资源,上下文的切换不会影响这些资源

线程拥有自己的私有数据比如栈和寄存器,上下文切换的时候需要提前保存

综上,线程的上下文切换将分为两个部分

两个线程不属于同一个进程,那么资源不共享,所以切换过程就会涉及到进程的上下文切换

第二种情况即两个线程属于同一个进程。因为共享虚拟内存,所以切换的时候这些资源保持不动,只需要切换线程的私有数据等不共享的数据

这也从侧面表明了,进程内的线程切换比多进程间的切换会节省不少资源,这也是多线程逐渐替代多进程的一个优势

那么调用又是怎么执行的

真的是一环接一环,是不是像极了面试,是的,我们对面试官的每一次回答都应该尽全力的让面试官上钩,问自己所能回答的问题不是。

如果用户态的程序要执行调用,则需要切换到内核态执行,这个过程如下图所示,一图胜千言

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图7)

调用过程

既然分为了用户态和内核态,两者权限级别不尽相同,用户态的程序发起调用,因为涉及到权限问题,不得不牵扯到特权指令,所以就会通过中断的方式执行,即上图的 Trap。

发生中断以后,内核程序就开始执行,处理完成又要触发 Trap,切换到用户态的工作,这里又涉及到了中断,我们这篇就先简单了解下中断。

中断做了什么?

我们以平时经常接触的键盘为例,当我们敲下键盘,主板收到按键后 CPU ,CPU 此时可能在忙处理其他程序,需要先中断当前执行的程序,将 PC 指针跳转到固定的位置,这就是一次中断的简单描述。

因此,当 CPU 接收到中断,根据中断类型操作 PC 指针,找到中断向量,修改中断向量,插入指令实现跳转功能。

进程和线程都出现了,那么怎么调度

计算机资源有限,太多的进程消耗机器自然受不住,我们一样,胃也有限嘛,一顿不吃饿得慌,可是吃多了也会走路脚颤抖不是,所以聪明的计算机也会想办法来处理这个问题。两手一挥,既然我们的 CPU 的核数有限,要不咋们给每个进程分配一个时间片,排队一个个执行,超出给定的时间就直接让另一个进程执行如何

时间片怎么分配?

假设此时有三个进程,进程1只需要 2 个时间片,进程 2 需要 1 个时间片,进程 3 需要 3 个时间片。进程 1 执行到一半的时候,累了,不想执行了,休息会(挂起)进程 2 执行,进程 2 一梭子就执行完了,进程 3 等不及了马上执行,执行三分之一后,进程1开始执行,这样循环根据时间片的执行方式即分时技术

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图8)

分时技术

刚才有说到进程的状态,那么有哪些状态?

一个进程的周期一般会分为下面三种状态

就绪状态:进程创建好了会开始排队,这个时候叫做“就绪状态”

运行状态:当一切准备就绪,天时地利人和后开始执行,此时为“运行状态”

如果将时间片用完了会再次变为就绪状态

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图9)

运行就绪

如果进程因为等待某个进程的完成,此时会进入阻塞状态

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图10)

进程阻塞

为什么需要阻塞状态?

我们想想,有的时候计算机会因为各种原因不能响应我们的请求,可能是因为等待磁盘,可能因为等待打印机,毕竟不会总是的及时的满足我们的需求,所以它这个时候通过中断告诉 CPU ,CPU 通过执行中断处理程序,将控制权给操作,操作随后将阻塞的进程状态修改为就绪状态,安排重新排队,再加上因为进程进入阻塞状态无事可做,但是又不能干瘪瘪的让他去排队(因为需要等待中断)所以进入到阻塞状态。

下面对以上所说的三种状态进行一个小结

就绪状态( Ready )可运行,只不过其他进程在运行暂时停止

运行( Running)此时进程占用 CPU

阻塞状态( blo ck ) 此时可能因为等待相关事件(请求 IO/等待 IO 完成等) 而停止运行,此时即使把 CPU 控制权给它,仍然无法运行

其实,进程还有两种基本状态

创建状态 ( New )进程刚被创建还没有提交时的状态,主要功能为分配和建立进程控制块等初始化工作。创建进程有两个阶段,第一个阶段为为新的进程创建必要的信息。第二个阶段为让进程进入就绪状态

终止状态 ( Exit )进程退出的状态,即回收除了进程控制块以外的资源。也分为两个阶段,第一个阶段为等待操作进行善后处理,第二个阶段为释放主存

所以一共就包含了五个状态,为了更加直观,其变迁图如下

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图11)

五种形态

Null---->创建状态:最初创建的第一个状态

创建状态----->就绪状态:进行一系列的初始化称为就绪状态

就绪状态----->运行状态:当操作调度就绪状态的进程并分配给 CPU 变为运行状态

运行状态------>结束状态:当进程完成相应任务或出错则作结束的状态

运行状态------>阻塞状态:运行状态的进程由于时间片用完,操作将进程更改为就绪状态

阻塞状态------->就绪状态:阻塞状态的进程等待某事件结束进入就绪状态

其实不是卖关子,实际上还有两种状态,分别是就绪挂起和阻塞挂起,那我们看看那这两者有啥不一样

挂起是一种行为,而阻塞是进程的状态

导致进程挂起的原因通常是因为内存不足或者用户的请求,进程的修改等,而进程的阻塞是进程正在等待某个事件发生,可能是等待资源或响应

挂起对应的是行为的激活,将外存中的进程调入内存中,而处于阻塞状态的进程需要等待其他进程或唤醒

挂起属于被动行为,进程被迫从内存转移到外存,而进入阻塞为主动的行为

综上,现在咱们的进程图就变为了七种状态,如下

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图12)

进程的七种状态

进程与线程的底层原理

上面我们了解了进程,线程的由来以及状态变迁,但是显然不能让我自如地了解进程和线程,至于其如何在内存表示等问题还是比较空虚的,所以我们继续往下看

进程和线程在内存中如何表示

在整个设计过程中,涉及了两张表,分别是进程表和线程表。其中进程表会记录进程在内存的位置,PID 是多少,以及当前什么状态,内存给它分配了多大使用空间以及属于哪个用户,假设没有这张表,操作就不知道有哪些进程,也就更不清楚怎么去调度,就仿佛失去 XXX,不知道了方向

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图13)

进程表

尤其需要注意进程表这样几个部分

资源信息

资源信息会记录这个进程有哪些资源,比如进程和虚拟内存怎么映射,拥有哪些文件等

内存布局

内存的知识点太多,如果在这里写文章将会非常的长,所以打算单独使用一篇文章写。

操作会告诉进程如何使用内存,大概分为哪些区域以及每个区域做什么。简单描述下下图各个段的作用。

堆:存放动态分配的数据,通常由人员自行,如果人员使用后不释放,那么程序结束后可能会作收回

数据段:存放的是全局变量和静态变量。其中初始化数据段(.data)存放显示初始化的全局变量和静态变量,未初始化数据段,此段通常也被称为BSS段(.bss)存放未进行显示初始化的全局变量和静态变量。

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图14)

进程内存布局

描述信息

描述信息包含进程的唯一识别号,进程的名称以及用户等

除了给进程安排一张表以外,给线程也安排了一张表,这就是线程表。线程表也包含了一个 ID,这 ID 叫做 ThreadID,同时也会记录自己在不同阶段的状态,比如阻塞,运行,就绪。由于多个线程会共用 CPU 且需要不停的切换,所以需要记录程序计数器和寄存器的值。

说到了用户级的线程和内核级的线程,两者又是怎么个亲密关系

两者映射的关系如何去表示?

可以想像在内核中有一个线程池,给予用户空间使用,每次用户级线程把程序计数器等传递过去,执行结束后,内核线程不销毁,等待下一个任务,从这里可以看出创建进程开销大、成本高;创建线程开销小,成本低。

这么多进程难道共用内存?

所以在正常的情况下 A 进程不能访问 B 进程的内存,除非你植入一个木马,恶意操作 B 进程的内存或者通过我们后面说的进程间通信的方式进行访问

那进程线程怎么切换的呢?

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图15)

进程切换

为了详细的让大家理解这个过程,我将其拆分为下面几个步骤

操作感知到有个进程需要切换,先发出一个中断信号给 CPU ,让其停止当前进程

CPU 收到中断信号后,正在执行的进程会停止,好心的操作会想办法先保存当前的状态

操作接管中断后,执行一段汇编程序帮助寄存器之前进程的状态

当操作保存好状态后就会执行调度程序,让其决定下一个将要执行的进程

最后操作会执行下一个进程

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图16)

进程与中断

中断以后如何恢复之前进程运行呢

上面说到操作会执行一段代码帮助进程恢复状态,其实现方式中,有一种方式即通过栈的先进后出的数据结构,所以对吧,大学中的基础课的好重要。

进程(线程)中断后,操作负责压栈关键数据(比如寄存器)恢复执行时,操作负责出栈和恢复寄存器的值。

协程

第一次接触协程是一次自动驾驶项目中,一起干活的同事说这个库底层使用了协程,我一脸懵逼,啊?携程?准备收拾行李回家了?半天想过来了,其有个底层库使用了协程,当时还一脸懵逼,进程,线程就已经够折了,怎么又来个协程,当时想着到时候面试官是不是又多了问问题的思路

什么是协程

协程和进程,线程的区别是什么

协程有什么优缺点

你们说头不秃怎么破?行嘛,为了生活,不,喜爱计算机,止不住学习的步伐,下面我们看看这个东西是什么

为什么需要协程?

我们在执行多任务的时候通常采用多线程的方式并发执行。我们以最近非常火热的电商促销茅台为例,不管茅台是在缓存中还是后端的数据,最开始的用户也就是 10 个,每当收到 10 条付款信息就开启 10 个线程去查询数据库,此时用户量少,马上就可第二天增加到 100 人,使用 100 个线程去查询,感觉确实效果不错,加大促销力度,当同时出现 1000 个人的时候感觉到有点吃力了

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图17)

增长的线程

1000-10000,看了前面的内容应该清楚创建销毁线程还是挺费资源的,假设每个线程占用 4M 内存空间,那么 10000 个线程大概需要消耗 39G 内存,可是也就 8G 内存。

此时的方案要么增加要么提升代码效率。多个线程在进行作业的时候,难免会遇到某个线程等待 IO 的情况,此时会阻塞当前线程切换到其他线程,使得其他线程照常执行,线程少的时候没什么问题,当线程数量变多就会出现问题,线程数量的增加不仅占用非常多的内存空间且过多的线程的切换也会占用大量的时间

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图18)

线程开销

此时就可以通过协程的方式解决这个问题

进程,线程,毕竟不会总是的及时的满足我们的需求,这就出现了线程(图19)

协程开销

类比上面,我们只需要启动 100 个线程,每个线程跑100个协程就可以完成上述同时处理10000个任务

那么协程在使用的过程中需要主要哪些内容呢

因此协程中,不能调用导致线程阻塞的操作,即协程最好与异步 IO 结合起来才能发挥最大的威力

怎么处理在协程中调用阻塞 IO 的操作呢

比较简答的思路是当调用阻塞 IO 的时候,重新启动一个线程去执行这个操作,等执行完成后,协程再去读取结果,这是不是和多线程很像

将 IO 进行封装,改为异步调用的方式,此时需要大量的工作,所以需要寄生于编程语言的原生支持

所以对于计算密集型的任务不太建议使用协程,计算机密集型的任务需要大量的线程切换,线程切换涉及太多的资源交换

总结

线程进程涉及的知识点好复杂,本文包含了线程,进程是什么,两者的区别,内核级线程与用户态线程,线程进程的上下文切换,调用的过程等一系列知识点,并没有对进程的调度等做详细的介绍。

本文相关词条概念解析:

线程

线程,计算机科学术语,有时也被称为轻量级进程(Light Weight Process,LWP),它是运行中的程序的调度单位。一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成。线程被包含在进程之中,是进程的一个实体,是CPU调度和分派的基本单位它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

网友评论