大名鼎鼎的 Linux —— 进程，线程，协程

夜深忽梦少年事丶
2,144 阅读12分钟

前言

Linux 作为当今服务端最流行的操作系统，是每个后端工程师应当熟练使用和理解的。本篇文章会详细讲述 Linux 系统中的一些基础概念：进程、线程，以及后面由各编程语言所实现的协程。

进程是什么？

进程是资源分配的最小单位

计算机专业的同学对这句话肯定不陌生，但是应该怎么去理解这句话？

程序是什么？

计算机程序（英语：Computer Program）是指一组指示电子计算机或其他具有消息处理能力设备每一步动作的指令，通常用某种程序设计语言编写，运行于某种目标体系结构上

上面是维基百科给出的解释，我们能把程序初步理解为一组 CPU指令集合

我们平时使用编程语言写的代码 （C,java,php,go...），也叫程序，本质上就是一堆字符串。只不过人类写的字符串 CPU 理解不了，CPU 能理解的东西不是正常人能写的，因此在我们写的程序和CPU能执行的指令之间，存在一种转换关系

这种转换关系通过 编译器/解释器 来实现

编译器

test.c

#include<stdio.h>

int main()
{
	printf("hello world\n");
	return 0;
}

首先这是一个 C语言程序,一个文本文件，位于磁盘的某个角落，CPU 肯定是看不懂的，所以需要做一层转换

gcc test.c -o test

gcc 就是一种编译器，把 C的文本程序转化为 ELF（Executable and Linkable Format）文件，并不是你所认为的二进制文件（binary）

ELF 文件也是一种可执行文件，其中也包含二进制内容，除此之外还有一些其他的信息

gcc 编译后的为 ELF 文件 image.png

go 编译后的二进制文件

image.png

解释器

解释器是一种直接执行高级语言代码的计算机程序, 而无需将代码编译成机器码

  • 优点: 消除了编译整个程序的负担，程序可以拆分成多个部分来模块化
  • 缺点: 解释器像是一位“中间人”,每次运行程序时都要先将代码转成另一种语言的代码,然后再作运行,因此解释器的程序运行速度比较缓慢

解释器执行代码的策略一般有以下三种:

  • 直接运行高级编程语言的代码（如 shell 内置的解释器 or php 的解释器）
  • 先将代码转换成高效的中间码（如:php opcode）,然后马上执行（不输出中间码，如 PHP-FPM 的执行）
  • 由解释器中内置的编译器先将高级语言的代码编译成中间码,然后再执行（输出中间码,相当于两个阶段,如 javac 先把源码编译成字节码，然后用 jvm 执行字节码）

image.png

不懂就问：先有编译器还是先有编程语言？

CPU 能识别的指令又叫做机器语言，格式为二进制的。假如 0000 表示 LOAD , 0001 表示 STORE

最开始的程序主要是为了做数学计算，初代程序员直接写机器指令运行 CPU，但是机器指令太反人类了，于是有个聪明的人说我用机器语言写一个程序，这个程序能干一件事：我把一个文件里的 LOAD 字符能转化成 0000，把STORE 字符转化成 0001（简单举个例子，实际 LOAD 不是 0000）

这个程序是通过机器语言写的，我们把这个程序叫做编译器，把包含 LOAD，STORE 等指令的语言叫做汇编语言，把字符转换的过程叫做汇编过程

那现在我们能通过汇编语言写出 CPU 能执行的代码，那之前那个编译器，我是不是还可以用汇编语言重新写一次？

汇编语言只是简单的通过指令转换，用一些汇编指令标识一系列的机器指令，但是还是很难写，能不能搞出一种正常人能写的编程语言？

那就设计一种语言吧！

C是一种通用的编程语言，广泛用于系统软件与应用软件的开发。于1969年至1973年间，为了移植与开发UNIX操作系统，由丹尼斯·里奇与肯·汤普逊，以B语言为基础，在贝尔实验室设计、开发出来

其实 C 语言和汇编之间还有一段历史，但是 C 语言由于其设计的优越性，被人们广泛运用。C语言的第一个编译器，是用 B 语言写的。看了上面你肯定知道 B 语言也是更低级的语言，其实编译器和编程语言的诞生，都是按照上面的逻辑

最后，上文使用的 gcc 编译器不是通过汇编写的，也不是通过 B 语言写的，而是通过 C/C++ 写的（当今时代的 gcc）

进程与程序

上文讲了一堆，无非是想搞清楚我们当前所使用的高级程序语言是如何一步步变成 CPU 所理解的机器语言，但是无论怎么转化，都始终只是硬盘里的一个文本文件，只有当真正执行的时候，才能成为操作系统里的一个进程

程序能执行起来，肯定不是你的功劳，实际上是你只是双击了两下程序图标，真正执行起程序的程序叫做操作系统

  1. 当我们双击程序图标或者键入程序名字后，操作系统根据程序的名字去磁盘中找到可执行程序

  2. 操作系统在内存为即将要运行的程序划出一块区域

  3. 操作系统将找到的可执行程序，然后从磁盘中程序信息copy到刚刚划分出的内存区域当中

  4. 操作系统在内存中找到可执行程序代码段的起始位置，假设这个地址是A

  5. 操作系统告诉CPU从A这个位置开始执行（其实没有这么简单）

我们现在知道程序运行起来以后就是一个进程，进程运行在内存里，那在这一块内存里，到底有哪些东西？我们能看到吗？

Linux 有一种哲学思想叫做一切皆文件，其实进程在 Linux 里面也会被抽象成文件的概念

/proc/pid

执行 ./test，然后 ps -ef，找到刚刚运行的进程号为 1100

image.png

cd /proc/1100 然后 ls -alh，你会发现一堆目录和文件

image.png

简单解释一下 /proc 目录，/proc 文件系统是一种虚拟文件系统,以文件系统目录和文件形式,提供一个指向内核数据结构的接口，通过它能够查看和改变各种系统属性。/proc 里面的数字开头的文件夹，就是当前系统中所运行的进程信息

进到进程目录里面能看到一堆和进程相关的数据：

  • cwd 软链接，指向进程工作目录
  • exe 软链接，指向进程的执行地址
  • fd 目录，存放进程打开的文件描述符
  • fdinfo 目录，存放进程打开的文件描述符的信息
  • maps 文件，进程打开相关文件的内存映射（比如 mmap 系统调用）
  • status 文件，保存进程的状态 running、sleep、ready 等
  • limits 文件，存放进程相关的一些限制条件 max open files 限制文件描述符的个数
  • environ 文件，存放环境变量
  • io 文件，记录进程 io 时读取的字节数
  • task 目录，这个目录很重要，因为里面放的每个目录对应的就是一个线程
  • ...

好了，至此应该知道一个进程执行时，操作系统会为程序分配内存，会记录程序各种各样的信息。而具体执行的东西是 task 目录下的线程。

可以理解为进程就像是一个环境，这个环境里有各种各样的资源，cpu 具体执行的是 task 目录下的线程，这些线程共享进程资源。单线程的程序 task 目录就一个线程，多线程的的程序 task 目录就有多个线程

执行 ps -efT，PID 为进程 ID，SPID 为线程 ID，下面是 redis 启动时，开启的线程数

image.png

操作系统眼中的进程是怎样的？

对于每个进程而言，大家都是相互独立的，你写的程序是不可能访问其他进程地址的数据和指令

因此操作系统为了隔离进程，给每个进程创建出了一个虚拟地址空间，意思是在每个进程都以为自己独立拥有整块内存，进程中的指令跳转、数据访问所使用的地址都是虚拟地址，因此不同的进程之间是不可能互相访问的

而实际上进程的数据是保存在物理内存的，因此每个进程的地址空间和物理内存之间存在一种映射关系，这种关系保存在每个进程的页表里

image.png

在操作系统眼里，用户程序是一个充满了bug随时会崩溃的定时炸弹（必须承认，我们写的代码里藏有很多bug...)，或者干脆就是某些天才程序员用来恶意控制整个计算机的破坏者。

操作系统面对的就是这样一个恶劣的环境。因此作为操作系统，应该把用户程序当做囚犯一样关在牢笼里面。

#include<stdio.h>

int main()
{
	printf("hello world\n");
	return 0;
}

再看一下上面的 test.c 程序，就干了一件事，打印 hello world 到标准输出（默认是控制台），这个过程是需要用户程序、操作系统、硬件三方合作才能完成的。

image.png

首先程序运行，当前处于用户态，然后代码执行到 printf 时，这里用户程序发起 write 系统调用，系统调用时会发出软中断(0x80)，让CPU 执行环境由用户态变为内核态，接下来内核执行 writev 系统调用对应的处理逻辑以及用户程序的传参，调用硬件驱动把数据写到控制台

类似的系统调用有很多，因此我们的应用程序很多时候都是在用户态和内核态之间进行一种切换。操作系统必须要保证硬件资源的合理利用，以及对各种硬件的合理访问。因此，对它而言用户程序是不可被信任的，因此对于硬件的操作都需要封装成系统调用，提供给用户程序，不会让用户程序直接操作

操作系统眼中的线程是怎样的？

上面看进程信息的时候已经说到了 task 目录，基本上大家就知道了进程和线程的关系了，为了更清晰的了解线程，首先看一下一个程序是怎么运行的

image.png

  • 程序是怎么运行的？
    • 很简单，把 main 函数地址放到 CPU 的 PC 寄存器就行
  • 什么是 PC 寄存器？
    • PC 寄存器存放CPU 即将执行的下一条指令的地址
  • 为什么要把 main 函数地址放到 PC 寄存器？
    • 因为 main 函数是程序的入口
  • 那我放其他函数的地址可不可以？
    • 当然可以，因为线程就是这么设计的

当我们把PC寄存器指向非 main 函数时，线程就诞生了

image.png

当然我 fork 一个线程肯定不是只为了执行一个函数，因此每个线程都会有自己独立的栈区以及寄存器组。当发生线程切换的时候，因为线程间共用进程地址，因此不需要切换进程上下文，只需要保存当前线程的数据以及执行到哪条指令，然后把 CPU 的 PC 寄存器指向下一个线程的执行地址就行

image.png

轻量级进程

其实对于cpu调度而言，操作系统调度的对象实际上是 /proc/$pid/task 目录的对象，线程和进程的区别无非是地址空间是独立的还是共享的，因此内核会为每个 task 对象创建一个 task_struct 结构体,这个结构体叫进程描述符。这些 task 对象拿到 cpu 时间片后，只有在时间片使用完、IO 阻塞、亦或者产生硬中断等外部条件时，才会暂停运行，也就是说线程是不会主动让出 cpu 时间片的，他们之间属于竞争关系

从 Linux 内核的角度看，它使用轻量级进程对多线程应用提供支持，其实它的创建也是基于fork()系统调用，只是在进程描述符的初始化当中有所区别。首先，轻量级进程也是一个进程，它有它自己的pid，有它自己的内核栈和进程描述符，甚至还有它自己的调度策略，而轻量级进程和普通进程不同的就是它没有自己的进程地址空间，并且要响应线程组内其他线程接收到的信号(但可以通过修改信号屏蔽字屏蔽某些信号)。轻量级进程使用的是父进程的内存地址空间，也就是在task_struct结构中的内存指针指向父进程的内存地址。而信号描述符指针会指向父进程指向的地址。而在应用层，线程有自己的栈

轻量级进程和普通进程区别：

  • 没有自己的进程地址空间，使用父进程的进程地址空间
  • 与组内所有进程共享信号，但有自己的信号屏蔽字

协程是什么？

上面说到线程之间是竞争关系，线程不会主动让出 cpu 时间片，因此当系统中的线程越来越多的时候，操作系统为了让每个线程都有机会执行，会频繁的进行线程切换。线程切换的代价比进程切换要少很多，因为各个线程之间共享进程地址空间，共享内存，共享全局数据等，因此只需要保存当前线程的局部变量，数据，以及 pc 寄存器的值，然后加载新线程的资源即可

用户态线程

对于 web 应用而言，线程切换最频繁的场景就在于 IO 了。当 IO 阻塞时，操作系统会挂起线程，然后让其他线程执行，不会让 cpu 傻傻等着

线程切换无非是改变 CPU 下一条指令执行的地址，那我们能不能在应用程序的用户态做到？

function main()
{
    A();
    B();
    C();
}

function A()
{
    //IO Blocking
}

function B()
{
    //IO Blocking
}

function C()
{
    //IO Blocking
}

上面这段代码，A，B，C，三个函数互不依赖，但是各自都有 IO 阻塞的代码。用传统的 php-fpm 执行，这个进程会阻塞三次，执行时间为 A+B+C；假如为这个三个函数各创建三个子线程，然后执行，理想情况下执行时间为 MAX(A,B,C)，但是存在线程切换（单核）

如果能在 A 进行 IO 阻塞时，让 cpu 执行函数 B 的指令，然后等 A 的 IO 结束后，再重新执行后续的逻辑。那么程序既不会挂起，也不需要进程线程切换，而且执行时间也是 MAX(A,B,C)

可以根据线程的思路，在用户态为这三个函数创建各自的栈，以及各自独立的内存空间，从 A 切换到 B 时，把 A 下一条该执行的指令地址和 A 的局部变量保存起来，然后把指令切换到 B 的初始地址。这个过程不需要操作系统，而是由用户态代码逻辑来切换。这样对于操作系统而言，这个程序实际上只阻塞了一次

协程调度

上面说到在 IO 阻塞的时候，会进行协程切换。那如何知道当前的 IO 是阻塞的呢？

答案就是之前写到的一篇文章——IO多路复用。通过 epoll/kqueue/select/poll 这些成熟的 IO 多路复用模型，能够获取到文件描述符是否能够读写的状态，由此来唤醒协程 or 切换协程

swoole

不同语言实现的的协程调度逻辑实际都不一样，上面我说到的方法是 php 的协程扩展 swoole 用到的方式。本来 php 是单线程执行的，而 swoole 则是维护了一堆协程栈，这些协程有自己的状态，通过 IO 多路复用函数，来改变协程的状态，从而不会让整个线程发生阻塞。但是因为 php 对线程的支持不是很好，所以 swoole 的协程是单线程的

golang

golang 这种编译型语言对各种 io 函数进行了封装，这些封装的函数提供给应用程序使用，而其内部调用了操作系统的异步 io函数，当这些异步函数返回 busy 或 bloking 时，golang 利用这个时机将现有的执行序列压栈，让线程去拉另外一个协程的代码来执行，并且 golang 的协程是多线程的

协程调度器

实际上 PHP 提供了语法糖，能改变函数的执行顺序，关键字叫 yield，函数中包含该关键字的，被称为 generator 对象。

<?php
function main()
{
    $t1 = test1();
    $t2 = test2();
    $queue = new SplQueue();
    $queue->enqueue(['is_start' => false, 'task' => $t1]);
    $queue->enqueue(['is_start' => false, 'task' => $t2]);
    while (true) {
        if ($queue->isEmpty()) {
            break;
        } else {
            $item = $queue->dequeue();
            if ($item['is_start']) {
                $item['task']->next();
            } else {
                $item['task']->rewind();
                $item['is_start'] = true;
            }
            if ($item['task']->valid()) {
                $queue->enqueue($item);
            }
        }
    }
    return true;
}

function test1()
{
    foreach ([1,2,3,4,5] as $i) {
        echo $i . PHP_EOL;
        yield;
    }
}

function test2()
{
    foreach ([10,20,30,40,50] as $i) {
        echo $i . PHP_EOL;
        yield;
    }
}

main();

image.png

上面的代码能够让 test1 和 test2 轮流执行，实际上创建了两个 generator，然后初始化一个队列，把他们添加到队列，while 循环从队列取数据，test1 执行到 yiled 后，会被重新添加到队尾，然后执行 test2。如果 test1 已经执行完了，就不会放入队列（使用 valid 判断)，这样就实现了大家轮流执行，一直到队列里面没有能够执行的任务后，就退出进程

带 yield 关键字的函数会在遇到 yield 的时候终止运行，然后记录下当前执行的地址，这样下次就能接着运行，也就是保存了当前函数的上下文，这么来说，是不是有点像协程？但实际上它只是一个关键字，我们可以通过它来实现一个 generator 调度器，类似于协程调度~

Github：用 yield 实现一个 generator 调度器

参考

[1]函数运行在内存中是什么样子

[2]线程与线程池

[3]Linux 内核源码解析

[4]线程间到底共享了哪些资源

[5]深入理解 swoole 协程实现

[6]cpu 上下文切换

[7]浅谈Linux 中的进程栈、线程栈、内核栈、中断栈

avatar
文章
阅读
粉丝

友情链接：