Linux线程【1概念】

最新推荐文章于 2024-06-04 23:11:16 发布

养乌龟的小少年

最新推荐文章于 2024-06-04 23:11:16 发布

阅读量834

点赞数 20

分类专栏： linux 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_45476980/article/details/136395533

版权

linux 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

前言：

一份代码成功编译后，成为可执行程序，运行起来，相关代码和数据被加载到内存中，操作系统为了管理进程，会先描述在组织，难道只有进程能够完成用户想要执行的任务吗？如果任务很大呢？为了满足高效运行的需求，需要一种执行力度更细的，成本更低的执行流，在linux操作系统中将这样的执行流称之为-线程

windos 中线程数据

正文：

1.什么是线程？

1.1基本概念

教材概念：

线程就是一个执行分支、执行粒度比进程更细、调度成本更低
线程就是进程内部的一个执行流

内核角度：

进程是承担系统资源分配的基本实体，而线程是 CPU 运行的基本单位

线程是对以往进程概念的补充完善，正确理解线程概念是一件十分重要的事

1.2线程理解

理解线程之前需要先简单回顾一下进程

程序运行后，相关的代码和数据会被 load 到内存中，然后操作系统为其创建对应的 PCB 数据结构、生成虚拟地址空间、分配对应的资源，并通过页表建立映射关系

进程之间是相互独立

即使是父子进程，他们也有各自的虚拟地址空间、映射关系、代码和数据（可能共享部分数据，出现修改行为时引发写时拷贝机制）

如果我们想要创建其他进程执行任务，那么虚拟地址空间、映射关系、代码和数据这几样东西是必不可少的，想象一下：如果只有进程的概念，并且同时存在几百个进程，那么操作系统调度就会变得十分臃肿

对于频繁IO操作，系统在调度进程时，需要频繁保存上下文数据、创建的虚拟地址空间及建立映射关系

为了避免这种繁琐的操作，引入了线程的概念，所谓线程就是：额外创建一个 task_struct 结构，该 task_struct 同样指向当前的虚拟地址空间，并且不需要建立映射关系及加载代码和数据，如此一来，操作系统只需要针对一个 task_struct 结构即可完成调度，成本非常低

为什么切换进程比切换线程开销大得多？
在 CPU 内部包括：运算器、控制器、寄存器、MMU、硬件级缓存（cache），其中硬件级缓存 cache 又称为高速缓存，遵循计算机设计的基本原则：局部性原理，会预先加载部分用户可能访问的数据以提高效率，如果切换进程，会导致高速缓存中的数据无法使用（进程具有独立性），重新开始预加载，这是非常浪费时间的（对于 CPU 来说）；但切换线程就不一样了，因此线程从属于进程，切换线程时，所需要的数据的不会发生改变，这就意味值高数缓存中的数据可以继续使用，并且可以接着预加载下一波数据

注：高速缓存中预加载的是公共数据，并非线程的私有数据

进程（process）的 task_struct 称为 PCB，线程（thread）的 task_struct 则称为 TCB

从今天开始，无论是进程还是线程，都可以称为执行流，线程从属于进程：当进程中只有一个线程时，我们可以粗粒度的称当前进程为一个单独的执行流；当进程中有多个线程时，则称当前进程为多执行流，其中每一个执行流就是一个个的线程

执行流的调度由操作系统负责，CPU 只负责根据 task_struct 结构进行计算

若下一个待调度的执行流为一个单独的进程，操作系统仍需创建 PCB 及虚拟地址空间、建立映射关系、加载代码和数据
但如果下一个待调度的执行流为一个线程，操作系统只需要创建一个 TCB，并将其指向已有的虚拟地址空间即可

1.3进程与线程的关系

进程是承担系统资源分配的实体，比如程序运行必备的：虚拟地址空间、页表映射关系、相关数据和代码这些都是存储在进程中的，也就是我们历史学习中进程的基本概念

线程是 CPU 运行的基本单位，程序运行时，CPU 只认 task_struct 结构，并不关心你是线程还是进程，不过，线程包含于进程中，一个进程可以只有一个线程，也可以有很多线程，当只有一个线程时，通常将其称为进程，但对于 CPU 来说，这个进程本质上仍然是线程；因为 CPU 只认 task_struct 结构，并且 PCB 与 TCB 都属于 task_strcut，所以才说线程是 CPU 运行的基本单位

总结：进程是由操作系统将程序运行所需地址空间、映射关系、代码和数据打包后的资源包，而线程/轻量级线程/执行流则是利用资源完成任务的基本单位

线程包含于进程中，进程本身也是一个线程

我们之前学习的进程概念是不完整的，引入线程之后，可以对进程有一个更加全面的认识

通常将程序启动，比如 main 函数中的这个线程称为 主线程，其他线程则称为 次线程

实际上一个完整的进程 = 内核PCB+虚拟地址空间+映射关系+代码和数据，同时线程又分割进程除了映射代码和数据以外的部分

在 Linux 中，认为 PCB 与 TCB 的共同点太多了，于是直接复用了 PCB 的设计思想和调度策略，在进行线程管理时，完全可以复用进程管理的解决方案（代码和结构），这可以大大减少系统调度时的开销，做到小而美，因此 Linux 中实际是没有真正的线程概念的，有的只是复用 PCB 设计思想的 TCB

在这种设计思想下，线程注定不会过于庞大，因此 Linux 中的线程又可以称为轻量级进程（LWP），轻量级进程足够简单，且易于维护、效率更高、安全性更强，可以使得 Linux 系统不间断的运行程序，不会轻易崩溃

与一切皆文件一样，这种设计思想注定 Linux 会成为一款卓越的操作系通

1.4线程使用

如何验证 Linux 中的线程解决方案？ 简单使用一下就好了

接下来简单使用一下 pthread 线程原生库中的线程相关函数（只是简单使用，不涉及其他操作）

#include <iostream>
#include <unistd.h>
#include <pthread.h>

using namespace std;

void *threadHandler1(void *args)
{
    while (true)
    {
        cout << "我是次线程1，我正在运行..." << endl;
        sleep(1);
    }
}

void *threadHandler2(void *args)
{
    while (true)
    {
        cout << "我是次线程2，我正在运行..." << endl;
        sleep(1);
    }
}

void *threadHandler3(void *args)
{
    while (true)
    {
        cout << "我是次线程3，我正在运行..." << endl;
        sleep(1);
    }
}

int main()
{
    pthread_t t1, t2, t3; // 创建三个线程
    pthread_create(&t1, NULL, threadHandler1, NULL);
    pthread_create(&t2, NULL, threadHandler2, NULL);
    pthread_create(&t3, NULL, threadHandler3, NULL);

    // 主线程运行
    while (true)
    {
        cout << "我是主线程" << endl;
        sleep(1);
    }

    return 0;
}

编译程序时，需要带上 -lpthread 指明使用 线程原生库

结果：主线程+三个次线程同时在运行

至于为什么打印结果会有点不符合预期，这就涉及到加锁相关问题了，后面再解决

使用指令查看当前系统中正在运行的线程信息

ps -aL | head -1 && ps -aL | grep myThread | grep -v grep

可以看到此时有 四个线程

细节1：四个线程的 PID 都是 13039
细节2：四个线程的 LWP 各不相同
细节3：第一个线程的 PID 和 LWP 是一样的

其中，第一个线程就是 主线程，也就是我们之前一直很熟悉的进程，因为它的 PID 和 LWP 是一样的，所以只需要关心 PID 也行

操作系统如何判断调度时，是切换为线程还是切换为进程？

将待切换的执行流 PID 与当前执行流的 PID 进行比对，如果相同，说明接下来要切换的是线程，否则切换的就是进程
操作系统只需要找到 LWP 与 PID 相同的线程，即可轻松锁定主线程

线程是进程的一部分，给其中任何一个线程发送信号，都会影响到其他线程，进而影响到整个进程

2.重谈地址空间

2.1页表的大小

页表是用来将 虚拟地址 和 物理地址 之间建立映射关系的，除此之外，页表中还存在 其他属性 字段

众所周知，在 32 位系统中，存在 2^32 个地址（一个内存单元大小是 1byte），意味着虚拟地址空间的大小为 4GB

假设极端情况：每个地址都在页表中建立了映射关系，其中页表的每一列大小都是 4 字节，那么页表的大小就是 2^32 * 4 * 3 * 1byte = 48GB，这就意味着悲观情况下页表已经干掉 48GB 的内存了，但现在电脑普遍都只有 16GB 内存，更何况是几十年前的电脑

所以页表的地址映射肯定不是这样的。

2.2、内存与磁盘的交互

操作系统从磁盘中读取数据时，一次读取大量数据比多次读取少量数据要快的多，因为磁盘是外设，每一次读取都必然伴随着寻址等机械运动（机械硬盘），无论是对于内存还是 CPU ，这都是非常慢的，为了尽可能提高效率，操作系统选择一次 IO 大量数据的方式读取数据

通常 IO 的数据以块为基本单位，在文件系统中，一个块的大小为 4KB（一个块由8个扇区组成，单个扇区大小为 512Byte），即使我们一次只想获取一个字节，操作系统最低也会 IO 一个数据块（4KB）

4KB 这个大小很关键

文件系统/编译器：文件存储时，需要以 4KB 为单位进行存储
操作系统/内存：读取文件或进行内存管理时，也是以 4KB 为单位的

也就是说，内存实际上是被切成大小为 4KB 的小块的，在内存中，单块内存（4KB）被称为 页 Page，组成单块内存的边界（类似于下标）被称为 页框（页帧）

为了将内存中的页 Page 进行管理，需要先描述，在组织，构建 struct page 结构体，用于描述页 Page 的状态，比如是否为脏数据、是否已经被占用了，因为存在很多页 Page，所以需要将这些 struct page 结构进行管理，使用的就是数组(天然有下标) struct page mem[N]，其中 N 表示当前内存中的页 Page 数量

struct page
{
	int status; // 基础字段：状态
	// 注意：这个结构不能设计的太复杂了，因为稍微大一点内存就爆了，所以里面的属性非常少
};

struct page mem[N]; // 管理 page 结构体的数组

假设我们的内存为 4GB，那么等分为 4KB 的页 Page，可以得到约 100w 个页 Page，其中 struct page 结构体不会设计的很大，大小是字节级别的，也就是说 struct page mem[100w] 占用的总大小不过 4~5MB，对于偌大的内存来说可以忽略不计

内存管理的本质：

申请：无非就是寻找 mem 数组中一块未被使用的足量空间，将对应的页 Page 属性设置为已被申请，并返回起始地址（足量空间页框的起始地址）
使用：将磁盘中的指定的 4KB 大小数据块存储至内存中对应的页 Page 中
释放：将页 Page 属性设置为可用状态

关于 mem 数组的查找算法（内存分配算法）：LRU、伙伴系统等

重新审视 4KB，为什么内存与磁盘交互的基本单位是 块（4KB）？

这里就要提一下 局部性原理 了

现代计算机预加载的理论基础
允许我们提前加载正在访问数据的相邻或者附加的数据（数据预加载）

所以现在就可以回答为什么是 4KB：

IO 的基本单位，内核系统/文件系统都对其提供了支持
利于通过局部性原理预测数据的命中情况，尽可能提高效率

总结：IO 的基本单位是 4KB，内存实际上被划分成了很多个 4KB 的小块，并存在相应的数据结构对其进行管理

2.3深入页表

虚拟地址（32 位操作系统）大小也就是 32 比特位，大概也就是 4Byte，通常将一个虚拟地址分割为三份：10、10、12

10：虚拟地址中的前 10 个比特位，用于寻址页表2
10：虚拟地址中间的 10 个比特位，用于寻找页框起始地址
12：虚拟地址中的后 12 个比特位，用于定位具体地址（偏移量）

注：“页表2” 中的 20 表示内存中的下标，即页框地址

通常将 “页表1” 称为 页目录，“页表2” 称为 页表项

页目录：使用 10 个比特位定位页表项
页表项：使用 10 个比特位定位页框地址
偏移量：使用 12 个比特位，在页 Page 中进行任意地址的寻址

像这种页框起始地址+偏移量的方式称为基地址+偏移量，是一种运用十分广泛的思想，比如所谓的类型（int、double、char…）都是通过类型的起始地址+类型的大小来标识该变量大小的，也就是说我们只需要获得变量的起始地址，即可自由进行偏移操作（如果偏移过度了，就是越界），这也就解释了为什么取地址只会取到起始地址

扩展：动态内存管理

实际上，我们在进行动态内存管理（malloc/new）申请堆空间时，操作系统并没有立即在物理内存中申请空间（因为你申请了可能不会立马使用），而是 先在虚拟地址中进行申请（成本很低），当我们实际使用该空间时，操作系统再去 填充相应的页表信息+申请具体的物理内存

像这种操作系统赌博式的行为我们已经不是第一次见了，比如之前的写时拷贝，就是在赌你不会修改，这样做的好处就是可以最大化提高效率，对于内存来说，这种使用时再申请的行为会引发缺页中断

同理，在进行 磁盘文件读取 时，也存在 缺页中断 行为，毕竟你打开文件了，并不是立即进行读写操作的

诸如这种硬件级的中断行为我们已经在信号产生中学过了，即：从键盘按下的那一刻，发出硬件中断信号，中断控制器识别为键盘发出的信号后，去中断向量表中查找执行方法，也就是键盘的读取方法

所以操作系统根本不需要关系硬件是什么样子，只需要关心对方是否发出了信号（请求），并作出相应的动作（执行方法）即可，很好的实现了解耦

对于内存的具体情况，诸如：是否命中、是否被占用、对应的 RWX 权限 需要额外的空间对其进行描述，而页表中的 其他属性 列就包含了这些信息

2.4小结

所以目前 地址空间 的所有组成部分我们都已经打通了，再次回顾这种设计时，会发现 用户压根不知道、也不需要知道虚拟地址空间之后发生的事，只需要正常使用就好了，当引发异常操作时，操作系统能在 查页表 阶段就进行拦截，而不是等到真正影响到 物理内存 时才报错

这种设计思想就是计算机界著名的所有问题都可以通过添加一层软件层解决，这种思想早在几十年前就已经得到了运用

这种分层结构不仅适用于 操作系统，还适用于网络，比如大名鼎鼎的 OSI 七层网络模型

3.线程概念总结

3.1、再谈线程

Linux 中没有真线程，有的只是复刻进程代码和管理逻辑的轻量级线程（LWP）

线程有以下概念：

在一个程序中的一个执行路线就叫做线程（Thread），或者说线程是一个进程内部的控制程序
每一个进程都至少包含一个主线程
线程在进程内部执行，本质上仍然是在进程地址空间内运行
在 Linux 系统中，CPU 看到的线程 TCB 比传统的进程 PCB 更加轻量化
透过进程地址空间，可以看到进程的大部分资源，将资源合理分配给每个执行流，就形成了线程执行流

3.2线程的优点

线程最大的优点就是轻巧、灵活，更容易进行调度

创建一个线程的代价比创建一个进程的代价要小得多
调度线程比调度进程要容易得多
线程占用的系统资源远小于进程
可以充分利用多处理器的并行数量（进程也可以）
在等待慢速 IO 操作时，程序可以执行其他任务（比如看剧软件中的 “边下边看” 功能）
对于计算密集型应用，可以将计算分解到多个线程中实现（比如压缩/解压时涉及大量计算）
对于 IO密集型应用，为了提高性能，将 IO操作重叠，线程可以同时等待资源，进行高效IO（比如文件/网络的大量 IO 需要，可以通过多路转接技术，提高效率）

3.3线程缺点

1、性能损失，当线程数量过多时，频繁的线程调度所造成的消耗会导致计算密集型应用无法专心计算，从而造成性能损失

2、健壮性降低，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的

为什么单个线程引发的错误需要让整个进程来承担？

站在技术角度，完全可以让其自行承担，但这不合理
系统角度：线程是进程的执行分支，线程出问题了，进程也不应该继续运行（比如一颗老鼠屎坏了一锅汤）
信号角度：线程出现异常后，MMU 识别到异常 -> 操作系统将异常转换为信号 -> 发送信号给指定进程，信号的对象是进程，自然无法单发给线程，进而整个进程也就都终止了

3、缺乏访问控制，进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响