线程的概念和控制

一、Linux线程概念

1-1 什么是线程

• 在一个程序里的一个执行路线就叫做线程 (thread)，更准确的定义是：一个进程内部的控制序列
• 一切进程至少都有一个执行线程
• 线程在进程内部运行，本质是在进程地址空间内运行
• 在Linux系统中，在CPU眼中，看到PCB都要比传统的进程更加轻量化
• 透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流

1-2 分页式存储管理

(1) 虚拟地址和页表的由来

思考一下，如果在没有虚拟内存和分页机制的情况下，每一个用户程序在物理内存上所对应的空间必须是连续的，如下图：

因为每⼀个程序的代码、数据长度都是不⼀样的，按照这样的映射方式，物理内存将会被分割成各种离散的、大小不同的块；经过⼀段运行时间之后，有些程序会退出，那么它们占据的物理内存空间可以被回收，导致这些物理内存都是以很多碎片的形式存在；怎么办呢？我们希望操作系统提供给用户的空间必须是连续的，但是物理内存最好不要连续；此时虚拟内存和分页便出现了，如下图所示：

把物理内存按照⼀个固定的长度的页框进行分割，有时叫做物理页；每个页框包含⼀个物理页 (page)；⼀个页的大小等于页框的大小；大多数 32位 体系结构支持 4KB 的页，而 64位体系结构⼀般会支持 8KB 的页；区分一页和⼀个页框是很重要的：

📍 页存在虚拟地址空间；页框存在物理内存中

1. 页框是一个存储区域
2. 而页是一个数据块，可以存放任何页框或磁盘中

有了这种机制，CPU便并非是直接访问物理内存地址，而是通过虚拟地址空间来间接的访问物理内存地址；所谓的虚拟地址空间，是操作系统为每⼀个正在执行的进程分配的⼀个逻辑地址，在32位机上，其范围从0 ~ 4G-1

操作系统通过将虚拟地址空间和物理内存地址之间建立映射关系，也就是页表，这张表上记录了每⼀ 对页和页框的映射关系，能让CPU间接的访问物理内存地址

总结⼀下，其思想是将虚拟内存下的逻辑地址空间分为若干页，将物理内存空间分为若干页框，通过页表便能把连续的虚拟内存，映射到若干个不连续的物理内存页；这样就解决了使用连续的物内存造成的碎片问题

(2) 物理内存管理

假设⼀个可用的物理内存有 4GB 的空间；按照⼀个页框的大小 4KB 进行划分， 4GB的空间就是 4GB/4KB = 1048576 个页框；有这么多的物理页，操作系统肯定是要将其管理起来的，操作系统需要知道哪些页正在被使用，哪些页空闲等等

内核用 struct page 结构表示系统中的每个物理页，出于节省内存的考虑， struct page 中使用了大量的联合体union

struct page 
{
    unsigned long flags;      // 状态标志：空闲、脏、锁定、保留等
    atomic_t count;           // 引用计数
    struct address_space *mapping; // 属于哪个地址空间（文件/匿名页）
    pgoff_t index;            // 在文件内的偏移
    struct list_head lru;     // LRU 链表（页面置换用）
    void *virtual;           // 内核虚拟地址（高端内存才用）
    // ... 还有很多字段
};

• flags：用来存放页的状态；这些状态包括页是不是脏的，是不是被锁定在内存中等；flag的每⼀位单独表示⼀种状态，所以它至少可以同时表示出 32 种不同的状态；这些标志定义在其中；其中⼀些比特位⾮常重要，如PG_locked用于指定页是否锁定， PG_uptodate用于表示页的数据已经从块设备读取并且没有出现错误

• _mapcount：表示在页表中有多少项指向该页，也就是这⼀页被引用了多少次；当计数值变为-1时，就说明当前内核并没有引用这一页，于是在新的分配中就可以使用它
• virtual：是页的虚拟地址；通常情况下，它就是页在虚拟内存中的地址；有些内存（即所谓的高端内存）并不永久地映射到内核地址空间上；在这种情况下，这个域的值为NULL，需要的时候，必须动态地映射这些页

要注意的是 struct page 与物理页相关，而并非与虚拟页相关；而系统中的每个物理页都要分配⼀个这样的结构体，让我们来算算对所有这些页都这么做，到底要消耗掉多少内存

算 struct page 占40个字节的内存吧，假定系统的物理页为 4KB 大小，系统有 4GB 物理内存；那么系统中共有页面 1048576个（1兆个），所以描述这么多页面的 page 结构体消耗的内存只不过 40MB ，相对系统 4GB 内存而言，仅是很小的⼀部分罢了；因此，要管理系统中这么多物理页面，这个代价并不算太大

要知道的是，页的大小对于内存利用和系统开销来说非常重要，页太大，页内必然会剩余较大不能利用的空间（页内碎片）；页太小，虽然可以减小页内碎片的大小，但是页太多，会使得页表太长而占用内存，同时系统频繁地进行页转化，加重系统开销；因此，页的大小应该适中，通常为 512B - 8KB ，windows / Linux系统的页框大小为4KB

(3) 页表

页表中的每⼀个表项，指向⼀个物理页的开始地址；在 32 位系统中，虚拟内存的最大空间是 4GB ， 这是每⼀个用户程序都拥有的虚拟内存空间；既然需要让 4GB 的虚拟内存全部可用，那么页表中就需要能够表示这所有的 4GB 空间，那么就⼀共需要 4GB/4KB = 1048576 个表项；如下图所示：

虚拟内存看上去被虚线"分割"成⼀个个单元，其实并不是真的分割，虚拟内存仍然是连续的；这个虚线的单元仅仅表示它与页表中每⼀个表项的映射关系，并最终映射到相同大小的⼀个物理内存页上

页表中的物理地址，与物理内存之间，是随机的映射关系，哪里可用就指向哪里(物理页)；虽然最终使用的物理内存是离散的，但是与虚拟内存对应的线性地址是连续的；处理器在访问数据、获取指令时，使用的都是线性地址，只要它是连续的就可以了，最终都能够通过页表找到实际的物理地址；假设，在 32 位系统中，地址的长度是 4 个字节，那么页表中的每⼀个表项就是占用 4 个字节；所以页表占据的总空间大小就是： 1048576*4 = 4MB的大小；也就是说映射表自己本身，就要占用 4MB / 4KB = 1024 个物理页；这会存在哪些问题呢？

• 回想⼀下，当初为什么使用页表，就是要将进程划分为⼀个个页可以不用连续的存放在物理内存中，但是此时页表就需要1024个连续的页框，似乎和当时的目标有点背道而驰了......
• 此外，根据局部性原理可知，很多时候进程在⼀段时间内只需要访问某几个页就可以正常运行了；因此也没有必要⼀次让所有的物理页都常驻内存

解决需要大容量页表的最好方法是：把页表看成普通的文件，对它进行离散分配，即对页表再分页， 由此形成多级页表的思想

为了解决这个问题，可以把这个单⼀页表拆分成 1024 个体积更小的映射表；如下图所示；这样⼀来，1024(每个表中的表项个数) * 1024(表的个数)，仍然可以覆盖 4GB 的物理内存空间

这里的每⼀个表，就是真正的页表，所以⼀共有 1024 个页表；⼀个页表自身占用 4KB ，那么 1024 个页表⼀共就占用了 4MB 的物理内存空间，和之前没差别啊？

从总数上看是这样，但是⼀个应用程序是不可能完全使用全部的 4GB 空间的，也许只要几十个页表就可以了；例如：⼀个用户程序的代码段、数据段、栈段，⼀共就需要 10 MB 的空间，那么使用 3 个 页表就足够了

(4) 页目录结构

到目前为止，每⼀个页框都被⼀个页表中的⼀个表项来指向了，那么这 1024 个页表也需要被管理起来；管理页表的表称之为页表录表，形成二级页表；如下图所示：

• 所有页表的物理地址被页目录表项指向
• 页目录的物理地址被 CR3 寄存器指向，这个寄存器中，保存了当前正在执行任务的页目录地址

所以操作系统在加载用户程序的时候，不仅仅需要为程序内容来分配物理内存，还需要为用来保存程序的页目录和页表分配物理内存

(5) 两级页表的地址转换

下面以⼀个逻辑地址为例；将逻辑地址（ 0000000000,0000000001,11111111111 ）转换为物理地址的过程：

1. 在32位处理器中，采用4KB的页大小，则虚拟地址中低12位为页偏移，剩下高20位给页表，分成两级，每个级别占10个bit（10+10）
2. CR3 寄存器 读取页目录起始地址，再根据⼀级页号查页目录表，找到下⼀级页表在物理内存中存放位置
3. 根据二级页号查表，找到最终想要访问的内存块号
4. 结合页内偏移量得到物理地址
5. 注：⼀个物理页的地址⼀定是 4KB 对齐的(最后的 12 位全部为 0 )，所以其实只需要记录物理页地址的高20位即可
6. 以上其实就是MMU的工作流程；MMU(Memory Manage Unit)是⼀种硬件电路，其速度很快， 主要工作是进行内存管理，地址转换只是它承接的业务之⼀

到这里其实还有个问题，MMU要先进行两次页表查询确定物理地址，在确认了权限等问题后，MMU再将这个物理地址发送到总线，内存收到之后开始读取对应地址的数据并返回；那么当页表变为N级时， 就变成了N次检索+1次读写；可见，页表级数越多查询的步骤越多，对于CPU来说等待时间越长，效率越低

让我们现在总结⼀下：单级页表对连续内存要求高，于是引入了多级页表，但是多级页表也是⼀把双刃剑，在减少连续存储要求且减少存储空间的同时降低了查询效率

有没有提升效率的办法呢？计算机科学中的所有问题，都可以通过添加⼀个中间层来解决；MMU引入了新武器，江湖人称快表的 TLB （其实就是缓存 Translation Lookaside Buffer，学名转译后备缓冲器）

当 CPU 给 MMU 传新虚拟地址之后， MMU 先去问 TLB 那边有没有，如果有就直接拿到物理地址发到总线给内存，齐活；但 TLB 容量比较小，难免发生 Cache Miss ，这时候 MMU 还有保底的老武器页表，在页表中找到之后 MMU 除了把地址发到总线传给内存，还把这条映射关系给到TLB，让它记录⼀下刷新缓存

(6) 缺页异常

设想，CPU给MMU的虚拟地址，在 TLB 和页表都没有找到对应的物理页，该怎么办呢？其实这就是缺页异常 Page Fault ，它是⼀个由硬件中断触发的可以由软件逻辑纠正的错误

假如目标内存页在物理内存中没有对应的物理页或者存在但无对应权限，CPU 就无法获取数据，这种情况下CPU就会报告⼀个缺页错误

由于 CPU 没有数据就无法进行计算，CPU罢工了用户进程也就出现了缺页中断，进程会从用户态切换到内核态，并将缺页中断交给内核的 Page Fault Handler 处理

缺页中断会交给 PageFaultHandler 处理，其根据缺页中断的不同类型会进行不同的处理：

• Hard Page Fault 也被称为 Major Page Fault ，翻译为硬缺页错误 / 主要缺页错误，这 时物理内存中没有对应的物理页，需要CPU打开磁盘设备读取到物理内存中，再让MMU建立虚拟地址和物理地址的映射
• Soft Page Fault 也被称为 Minor Page Fault ，翻译为软缺页错误 / 次要缺页错误，这 时物理内存中是存在对应物理页的，只不过可能是其他进程调入的，发出缺页异常的进程不知道而已，此时MMU只需要建立映射即可，无需从磁盘读取写入内存，⼀般出现在多进程共享内存区域
• Invalid Page Fault 翻译为无效缺页错误，比如进程访问的内存地址越界访问，又比如对空指针解引用内核就会报 segment fault 错误中断进程直接挂掉

📍 注意：

• 如何理解我们之前的 new 和 malloc ？（分配虚拟页，管理虚拟地址空间的块，最终通过页表映射到物理页）
• 如何理解我们之前学习的写时拷贝？（写时拷贝，本质是通过页表权限控制，实现 "只读共享、写时复制"，避免了不必要的物理内存拷贝）
• 申请内存，究竟是在干什么？（申请虚拟地址空间，建立页表映射）

如何区分是缺页了，还是真的越界了？

• ⼀个问题，越界了⼀定会报错吗？
• 页号合法性检查：操作系统在处理中断或异常时，首先检查触发事件的虚拟地址的页号是否合法；如果页号合法但页面不在内存中，则为缺页中断；如果页号非法，则为越界访问
• 内存映射检查：操作系统还可以检查触发事件的虚拟地址是否在当前进程的内存映射范围内；如果地址在映射范围内但页面不在内存中，则为缺页中断；如果地址不在映射范围内，则为越界访问
• 线程资源划分的真相：只要将虚拟地址空间进行划分，进程资源就天然被划分好了

1-3 线程优点

• 创建⼀个新线程的代价要比创建⼀个新进程小得多
• 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多

1. 最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的；这两种上下文切换的处理都是通过操作系统内核来完成的；内核的这种切换过程伴随的最显著的性损耗是将寄存器中的内容切换出
2. 另外⼀个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制；简单的说，⼀旦去切换上下文，处理器中所有已经缓存的内存地址⼀瞬间都作废了；还有⼀个显著的区别是当你改变虚拟内存空间的时候，处理的页表缓冲 TLB （快表）会被全部刷新，这将导致内存的访问在⼀ 段时间内相当的低效；但是在线程的切换中，不会出现这个问题，当然还有硬件cache

• 线程占用的资源要比进程少
• 能充分利用多处理器的可并行数量
• 在等待慢速I / O操作结束的同时，程序可执行其他的计算任务
• 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
• I / O密集型应用，为了提高性能，将I / O操作重叠；线程可以同时等待不同的I / O操作

1-4 线程缺点

• 性能损失

⼀个很少被外部事件阻塞的计算密集型线程往往无法与其它线程共享同⼀个处理器；如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这立的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变（为了保证线程与共享资源的安全性，必须要有的性能损失）

• 健壮性降低

编写多线程需要更全卖弄更深入的考虑，在⼀个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的（一个线程的错误会影响整个进程）

• 缺乏访问控制

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

• 编程难度提⾼

编写与调试⼀个多线程程序比单线程程序困难得多

1-5 线程异常

• 单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃
• 线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出

1-6 线程用途

• 合理的使用多线程，能提高CPU密集型程序的执行效率
• 合理的使用多线程，能提高|O密集型程序的用户体验（如生活中我们⼀边写代码⼀边下载开发工具，就是多线程运行的⼀种表现）

2、 Linux进程 VS 线程 ------ 哪些资源共享，哪些独占

• 进程间具有独立性
• 线程共享地址空间，也就是共享进程资源

2-1 进程和线程

• 进程是资源分配的基本单位
• 线程是调度的基本单位
• 线程共享进程数据，但也拥有自己的一部分"私有"数据

如：线程ID、一组寄存器，线程上下文数据、栈、errno、信号屏蔽字、调度优先级

2-2 进程的多个线程共享

同⼀地址空间，因此 Text Segment 、 Data Segment 都是共享的，如果定义⼀个函数，在各线程中都可以调用，如果定义⼀个全局变量，在各线程中都可以访问到，除此之外，各线程还共享以下进程资源和环境:

• 文件描述符
• 每种信号的处理方式
• 当前工作目录
• 用户id和组id

进程和线程的关系如下图:

三、 Linux线程控制

3-1 POSIX线程库

• 与线程有关的函数构成一个完整的系列，绝大多数函数的名字都是以 "pthread_" 打头的
• 要使用这些函数库，要通过引入头文件 <pthread.h>
• 连接这些线程函数库时要使用编译器命令的 "-lpthread" 选项

3-2 创建线程

功能：创建⼀个新的线程
原型：

   int pthread_create(pthread_t *thread, const pthread_attr_t* attr, void*
(*start_routine)(void*), void* arg);
 
参数:
    thread:返回线程ID
    attr:设置线程的属性，attr为NULL表示使⽤默认属性
    start_routine:是个函数地址，线程启动后要执⾏的函数
    arg:传给线程启动函数的参数

返回值：成功返回0；失败返回错误码

错误检查：

1. 传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误
2. pthreads函数出错时不会设置全局变量errno (而大部分其他POSIX函数会这样做)；而是将错误代码通过返回值返回
3. pthreads同样也提供了线程内的errno变量，以支持其他使用errno的代码；对于pthreads函数的错误，建议通过返回值来判定，因为读取返回值要比读取线程内的errno变量的开销更小

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>

void *rout(void *arg) 
{
    int i;
    for( ; ; ) 
    {
        printf("I'am thread 1\n");
        sleep(1);
    } 
}

int main( void )
{
    pthread_t tid;
    int ret;
    if ( (ret=pthread_create(&tid, NULL, rout, NULL)) != 0 ) 
    {
        fprintf(stderr, "pthread_create : %s\n", strerror(ret));
        exit(EXIT_FAILURE);
    }
    int i;
    for(; ; ) 
    {
        printf("I'am main thread\n");
        sleep(1);
    }
}

///////////////////////////////////////////////////////////////////
#include <pthread.h>

// 获取线程ID 
pthread_t pthread_self(void);

打印出来的 tid 是通过 pthread 库中有函数 pthread_self 得到的，它返回⼀个 pthread_t 类型的变量，指代的是调用 pthread_self 函数的线程的 "ID"

怎么理解这个"ID"呢？这个"ID"是 pthread 库给每个线程定义的进程内唯⼀标识，是 pthread 库维持的

由于每个进程有自己独立的内存空间，故此"ID"的作用域是进程级而非系统级（内核不认识）

其实 pthread 库也是通过内核提供的系统调用（例如clone）来创建线程的，而内核会为每个线程创建系统全局唯⼀的"ID"来唯⼀标识这个线程

使用PS命令查看线程信息

运行代码后执行：

$ ps -aL | head -1 && ps -aL | grep mythread
 PID LWP TTY TIME CMD
2711838 2711838 pts/235 00:00:00 mythread
2711838 2711839 pts/235 00:00:00 mythread

-L 选项：打印线程信息

LWP 是什么呢？LWP得到的是真正的线程ID；之前使用 pthread_self 得到的这个数实际上是⼀个地址，在虚拟地址空间上的⼀个地址，通过这个地址，可以找到关于这个线程的基本信息，包括线程ID，线程栈，寄存器等属性

在 ps -aL 得到的线程ID，有⼀个线程ID和进程ID相同，这个线程就是主线程，主线程的栈在虚拟地址空间的栈上，而其他线程的栈在是在共享区（堆栈之间），因为pthread系列函数都是 pthread 库提供给我们的；而pthread库是在共享区的；所以除了主线程之外的其他线程的栈都在共享区

3-3 线程终止

如果需要只终止某个线程而不终止整个进程，可以有三种方法：

1. 从线程函数return；这种方法对主线程不适用，从main函数return相当于调用exit
2. 线程可以调用 pthread_exit 终止自己
3. ⼀个线程可以调用 pthread_cancel 终止同⼀进程中的另⼀个线程

pthread_exit 函数

功能：线程终⽌
原型:
 void pthread_exit(void *value_ptr);
 
参数:
 value_ptr:value_ptr不要指向⼀个局部变量。
 
返回值：
 ⽆返回值，跟进程⼀样，线程结束的时候⽆法返回到它的调⽤者（⾃⾝）

需要注意，pthread_exit 或者 return 返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了

pthread_cancel 函数

功能：取消⼀个执⾏中的线程

原型:
 int pthread_cancel(pthread_t thread);
 
参数:
 thread:线程ID

返回值：成功返回0；失败返回错误码

3-4 线程等待

为什么需要等待线程？

• 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内
• 创建新的线程不会复用刚才退出线程的地址空间（刚退出的线程要被等待成功，才会将空间释放出来）

功能：等待线程结束

原型
    int pthread_join(pthread_t thread, void** value_ptr);
 
参数:
    thread:线程ID
    value_ptr:它指向⼀个指针，后者指向线程的返回值
 
返回值：成功返回0；失败返回错误码

调用该函数的线程将挂起等待，直到id为thread的线程终止；thread线程以不同的方法终止，通过 pthread_join 得到的终止状态是不同的，总结如下：

1. 如果thread线程通过return返回，value_ptr所指向的单元里存放的是 thread线程函数的返回值
2. 如果thread线程被别的线程调用 pthread_cancel 异常终掉，value_ptr 所指向的单元里存放的是常数 PTHREAD_CANCELED
3. 如果thread线程是自己调用pthread_exit终止的，value_ptr所指向的单元存放的是传给 pthread_exit 的参数
4. 如果对thread线程的终止状态不感兴趣，可以传NULL给 value_ptr 参数

3-5 线程分离

• 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行 pthread_join 操作，否则无法释放资源，从而造成系统泄漏
• 如果不关心线程的返回值，join是⼀种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源

int pthread_detach(pthread_t thread);

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离：

pthread_detach(pthread_self());

joinable和分离是冲突的，⼀个线程不能既是joinable又是分离的（分离后，不能再join）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

void *thread_run( void * arg )
{
    pthread_detach(pthread_self());
    printf("%s\n", (char*)arg);
    return NULL;
}

int main( void )
{
    pthread_t tid;
    if ( pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0 ) 
    {
        printf("create thread error\n");
        return 1;
    }
    int ret = 0;
    sleep(1);//很重要，要让线程先分离，再等待 
    if ( pthread_join(tid, NULL ) == 0 ) 
    {
        printf("pthread wait success\n");
        ret = 0;
    } 
    else 
    {
        printf("pthread wait failed\n");
        ret = 1;
    }
    return ret;
}

四、 线程ID及进程地址空间布局

• pthread_create 函数会产生⼀个线程ID，存放在第⼀个参数指向的地址中；该线程ID和前面说的线程ID不是⼀回事
• 前面讲的线程ID属于进程调度的范畴；因为线程是轻量级进程，是操作系统调度器的最小单位， 所以需要⼀个数值来唯⼀表示该线程
• pthread_create 函数第⼀个参数指向⼀个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴；线程库的后续操作，就是根据该线程ID来操作线程的
• 线程库NPTL提供了 pthread_self 函数，可以获得线程自⾝的ID：

    pthread_t pthread_self(void);

pthread_t 到底是什么类型呢？取决于实现；对于Linux目前实现的NPTL实现而言，pthread_t 类型的线程ID，本质就是⼀个进程地址空间上的⼀个地址

📍 因为 tid 和 TCB 与线程栈都是被pthread库维护的，并且线程需要共享进程内的信息，例如信号处理方法、进程ID、权限等，所以是存在共享区中的

五、 线程封装

#pragma once
#include <functional>
#include <iostream>
#include <pthread.h>
#include <string>

namespace ThreadModule
{
// 原⼦计数器，⽅便形成线程名称
std::uint32_t cnt = 0;
// 线程要执⾏的外部⽅法，我们不考虑传参，后续有std::bind来进⾏类间耦合
using threadfunc_t = std::function<void()>;
// 线程状态
enum class TSTATUS
{
    THREAD_NEW,
    THREAD_RUNNING,
    THREAD_STOP
};
// 线程
class Thread
{
  private:
    static void* run(void* obj)
    {
        Thread* self = static_cast<Thread*>(obj);
        pthread_setname_np(pthread_self(), self->_name.c_str()); // 设置线程名称
        self->_status = TSTATUS::THREAD_RUNNING;
        if (!self->_joined)
        {
            pthread_detach(pthread_self());
        }
        self->_func();
        return nullptr;
    }
    void SetName()
    {
        // 后期加锁保护
        _name = "Thread-" + std::to_string(cnt++);
    }

  public:
    Thread(threadfunc_t func) : _status(TSTATUS::THREAD_NEW), _joined(true), _func(func) { SetName(); }
    void EnableDetach()
    {
        if (_status == TSTATUS::THREAD_NEW)
            _joined = false;
    }
    void EnableJoined()
    {
        if (_status == TSTATUS::THREAD_NEW)
            _joined = true;
    }
    bool Start()
    {
        if (_status == TSTATUS::THREAD_RUNNING)
            return true;
        int n = ::pthread_create(&_id, nullptr, run, this);
        if (n != 0)
            return false;
        return true;
    }
    bool Join()
    {
        if (_joined)
        {
            int n = pthread_join(_id, nullptr);
            if (n != 0)
                return false;
            return true;
        }
        return false;
    }
    ~Thread() {}

  private:
    std::string _name;
    pthread_t _id;
    TSTATUS _status;
    bool _joined;
    threadfunc_t _func;
};
} // namespace ThreadModule

// main.cc
#include "test.hpp"
#include <iostream>
#include <unistd.h>
void hello1()
{
    char buffer[64];
    pthread_getname_np(pthread_self(), buffer, sizeof(buffer) - 1);
    while (true)
    {
        std::cout << "hello world, " << buffer << std::endl;
        sleep(1);
    }
}

void hello2()
{
    char buffer[64];
    pthread_getname_np(pthread_self(), buffer, sizeof(buffer) - 1);
    while (true)
    {
        std::cout << "hello world, " << buffer << std::endl;
        sleep(1);
    }
}

int main()
{
    pthread_setname_np(pthread_self(), "main");
    ThreadModule::Thread t1(hello1);
    t1.Start();
    ThreadModule::Thread t2(std::bind(&hello2));
    t2.Start();
    t1.Join();
    t2.Join();
    return 0;
}

六、 补充

• 进程：运行起来的程序------>进程=内核数据结构+代码和数据------>是承担分配系统资源的基本实体------>多个线程+地址空间+页表+代码和数据
• 线程是进程内部的执行分支（线程属于操作系统调度的基本单位）
• 创建进程，就要预先申请一大批资源：内存，CPU，IO......
• 问：CPU需要严格区分进程还是线程么？

答：不需要，线程是属于OS调度的基本单位；在CPU的视角中，没有进程，没有线程，只有执行流（轻量级进程）

• Linux中：程序员复用进程相关的数据结构，task_struct（用进程的内核数据结构实现线程效果）
• Linux中：执行流==轻量级进程（进程=一个或者多个轻量级进程+其他资源）
• 线程控制块是管理线程的核心结构，它需要复制PCB不止是依附于所属进程的PCB；TCB只包含线程专属的少量信息：线程标识符、线程调度状态、优先级、程序计数器、寄存器上下文、栈指针等等；它共享进程所有的内存空间、资源句柄（文件描述符等）等所有资源
• 一个进程的多个线程共用一个PCB关联的资源池，每个线程只拥有自己的执行上下文与栈，需要复制父线程的PCB
• 地址空间第四讲------页表+虚拟地址+物理地址------页表本质认识

1. 页框 / 页帧：是指物理内存中固定大小的连续存储块
2. 内存和磁盘数据交换，在文件系统角度基本单位是4KB
3. OS需要对页框进行管理------先描述，再组织（很小，只有十几字节，因为使用联合体存储）
4. 是一个名为 struct page mem[1048576]的数组；页框的物理地址------>数组下标，页框内任意一个地址都可以直接找到它所处的page的属性

• 页目录中所存地址的前20位是页表项的物理地址
• 页表项中所存地址的前20位是4KB块的物理地址
• **它们两个的后12位都是权限，**页目录的物理地址存在CR3寄存器中
• 拿虚拟地址，经过前10位可以找到对应的页目录，中间10位可以找到对应的页表项，最后十二位可以找到在物理内存中的偏移
• 虚拟地址转化物理地址步骤

1. CPU从CR3中读取页目录表的物理基地址，结合前10位的页目录项引索，找到对应的页目录项，该目录项存储了页表的物理地址
2. 页表的物理基地址结合中间10位的页表项索引，找到对应的页表项，该表项存储了物理页面的基地址
3. 将物理页面的及地址与最后12位的页内偏移量相加，得到最后的物理地址
4. 物理地址=页框起始地址+虚拟地址的低12位

• 页表大小：1024+1=1025 * 1024=4MB+4KB
• 单个进程不可能永远全部内存，当前进程页表总数远远小于4MB

1. 拥有更多虚拟地址就意味着拥有更多的内存资源
2. 在编译阶段：只要我们把虚拟地址进行划分本质就是把物理内存划分
3. 懒加载，页表少（因此机制，页表会更少）（例如：写时拷贝，缺页中断实现懒加载）局部性原理

• 任何一个页框的地址，用多少位表示就足够了？

用20位比特位就足够了，剩下12位用来表示标志位

页目录项、页表中的地址是物理地址，页目录存的是页表的物理基地址；页表存的是物理页面的物理基地址，直接指向物理内存中的页表或者数据

• 刚刚我们讲的内容由谁来完成？

MMU硬件自动帮我们完成映射转换；转换失败------>权限、不存在、共享写入、虚拟地址合法、但是物理地址不存在（异常、中断）

• 共享写入------>会触发写时复制异常

1. 因为多个进程共享一个物理页时，此时对应的页表会被标记成只读，同时共享计数（无法写入）
2. 当一个进程要写入共享内存时，会触发异常；此时会把共享内存中的内容复制一份，并且写入所要的数据，此进程再指向新的物理页，并且此物理内可写，原共享内存计数 -1
3. 若不是合法cow场景，则触发段错误终止进程

• CR3寄存器，也称为页目录基址寄存器

1. CR3页目录的起始地址是物理地址
2. CR3寄存器就是进程的上下文
3. CR2存储页错误线性地址，引起崩溃的地址写到CR3寄存器内部

• 页表的本质

📍 是进程看到内存资源的窗口，拥有的虚拟地址越多，拥有的物理内存也就越多，划分区域，划分虚拟地址

让不同的PCB执行进程代码的一部分，让不同的PCB执行不同的函数，让不同的PCB用户不同的代码区对应的虚拟地址空间

• 创建 / 删除一个新线程的代价要比一个新进程小得多
• 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
• cache缓存（硬件）

1. 用于解决CPU与主存之间速度不匹配问题的高速缓存存储器，它基于局部性原理
2. 核心原理：时间局部性原理、空间局部性；cache会优先缓存具有局部性的数据集，让CPU尽可能直接从cache中获取数据，而非速度更慢的主存
3. 在进程切换场景中，理解"丢弃cache，重新进行命中缓存冷------>热"，当OS从一个进程切换到另一个进程时，原进程在CPU cache中缓存的所有数据 / 指令会被"丢弃"，新进程开始运行时，其需要的指令和数据最初并不在 cache 中（此时处于冷状态）；随着新进程的执行，CPU会逐步将新进程的热点数据 / 指令加载到 cache 中，cache命中率逐渐提升，最终进入热状态（即cache中缓存了足够多的新进程热点数据，能高效响应CPU访问）
4. 🔺 为什么会有冷热状态？

因为cache是硬件资源：不同进程的地址空间是独享的，原进程的cache数据对新进程没有意义；新进程需要创建自己的cache

• 线程等待

新线程必须被主线程等待：类似子进程那里的僵尸问题（必须）；主线程要获取新线程的执行结果（非必须）

• 分离线程

1. 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_read操作，否则无法释放资源，从而造成泄漏
2. 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放资源
3. 线程分离是一种状态

• 线程ID（tid）（一个地址）；是OS / 编程语言为每个线程分配的唯一标识符，用于区分不同的线程，类比成线程的"身份证号"

1. 内核TID：OS内核分配TID，全局唯一（同一系统中不同进程的TID不重复）
2. 用户TID：编程语言在用户层分配TID，仅在当前进程内唯一
3. pthread库也是库，要被映射到当前进程的虚拟地址空间以支持线程控制

• 理解"线程执行流可以退出，但是tcb可以暂时保存"

1. 当线程执行流退出后，它的CPU执行上下文会立即销毁，不再参与调度，但TCB会保留
2. TCB中的信息是其他线程用pthread_join()时的查询依据
3. 如若线程不被设置成分离状态或者不被其他线程获取到退出信息，对应线程就变成了"僵尸线程"

• 理解 struct_pthread : struct task_struct=1 : 1

1 : 1式的用户级线程

1. 一个用户态pthread结构体对应一个内核态task_struct结构体结构体
2. 线程库会构造一个pthread结构体，用于管理该线程的用户态上下文，并建立它内核task_struct的映射关系
3. 二者的生命周期完全绑定
4. 过去我们总把 struct task_struct 当作进程PCB，其实不然，PCB的严格意义是内核调度实体的控制结构，只是线程的PCB会共享同一个进程的地址空间、文件描述符、信号处理等资源