文章目录

📖 前言
1. 线程的引入
- 1.1 执行流：
- 1.2 线程的创建：
- 1.3 线程的等待：
2. 查看线程
- 2.1 链接线程库：
- 2.2 ps -aL：
3. 页表的认识
- 3.1 二级页表：
- 3.2 页表的实际大小：
4. 再看线程
- 4.1 线程总结：
- 4.2 线程的优点：
- 4.3 线程的缺点：

📖 前言

从本章开始，我们进入Linux系统编程最后一节多线程的学习，本章我们先来简单的认识一下线程。

1. 线程的引入

在我们之前的Linux学习中，学习了进程的相关概念，操作系统内核中的task_struct描述进程，CPU在运行时，会根据时间片轮询调度进程，让每个进程得以推进。

在之前进程地址空间的学习中，我们知道，每个进程的PCB都可以看到一整个进程地址空间，我们以前学的进程是一个PCB对应一个进程地址空间。

而线程我们可以理解为轻量级进程，每一个进程都可以创建多个线程，并行执行不同的代码。

线程 : 进程 = n : 1
在这里插入图片描述
创建的这三个PCB有了属于它们自己的一小份代码和数据。那么我们把这里的其中一个task_ struct对应的占有这个的进程的一小份代码，一小份数据，使用它局部的一部分页表的，这样的执行流task_struct在Linux中叫做线程。

不再独立分配独立的地址空间。
不再分配独立页表，而是所有PCB指向同一个地址空间，甚至将来访问同一张页表。

CPU看待进程和线程是一样的，调度的时候都是以task_struct为单位来调度的。

TCB(Thread Control Block)
PCB(Process Control Block)

Windows中：

真线程的操作系统当中，pcb和tcb非常复杂。
在真正的线程操作系统中，TCB (Thread Control Block)和PCB(Process Control Block)是分开实现的。

Linux中：

进程和线程在概念上没有区分，只有一个叫做执行流！
进程有优先级，线程也有优先级，都要切换，都要上下文保护，也要找到对应的代码和数据。
无非是，进程的代码和数据多一些，线程的代码和数据少一些，进程做的工作更多，线程少。

Linux的线程是用进程模拟的PCB模拟的，Linux下也有tcb只不过没有为线程单独设计，用的照样是task_struct。

Linux没有提供纯纯的创建线程接口，因为底层没有用真线程，用的是进程作为载体去模拟线程。

进程具有独立性是，有自己的资源，地址空间，页表还有该进程加载到内存中的代码和数据。

以前创建进程是创建独立进程，PCB、地址空间和页表是私有的。

创建线程只创建PCB，CPU调度时，只看PCB。

小结：

在进程内部运行的执行流。
线程比进程粒度更细，调度成本更低。
线程是CPU调度的基本单位。

1.1 执行流：

进程和线程在执行流层面是不一样的。

在Linux中，执行流（Execution Flow）是指程序的执行过程中的控制流动。它描述了程序中指令的顺序执行路径，决定了程序的执行顺序。

单执行流进程：单执行流进程是指在计算机系统中，每个进程只有一个执行线程，即同一时间只能执行一个指令或一个操作。
多执行流进程：多执行流进程是指在计算机系统中，一个进程可以同时拥有多个执行线程，即能够同时执行多个指令或多个操作。

fork之后，父子是共享代码的可以通过if else判断，让父子进程执行不同的代码块不同的执行流，可以做到进行对特定资源的划分。

进程：向系统申请资源的基本单位（系统分配）
线程：系统调度的基本单位

进程（Process）和线程（Thread）在执行流层面上是不一样的：

进程（Process）：
- 进程是操作系统中的一个独立执行单位，它具有独立的内存空间、程序代码和执行环境。
- 每个进程都有自己的执行流，包括程序计数器（Program Counter）和栈，用于存储指令的地址和局部变量等信息。
- 进程之间相互独立，并且可以通过进程间通信机制进行数据交换。
线程（Thread）：
- 线程是进程内的一个执行单元，一个进程可以包含多个线程。
- 与进程不同，线程共享同一个进程的地址空间和资源，在同一个进程中的线程之间可以直接访问共享的内存区域和变量，而无需使用进程间通信的机制。
- 线程之间可以并发执行，共享进程的执行环境，包括打开的文件、信号处理函数、信号屏蔽字等。

本来串行执行的代码，现在在CPU上可以并发或者并行去执行，让代码在一个时间段或者一个时间点同时得以推进，这种解决方案就叫做线程。

再看进程：

进程 = 内核数据结构 + 进程对应的代码和数据。
进程 = 内核视角：承担分配系统资源的基本实体（进程的基座属性）

再说进程就是PCB就不准确了。包括地址空间，页表，包括构建的映射关系，包括在内存中申请的各种代码和数据对应的内存，包括对应的PCB合起来这一堆才叫进程。

进程的最大意义不是被执行而是：向系统申请资源的基本单位！

内部只有一个执行流的进程 —— 单执行流进程
内部有多个执行流的进程 —— 多执行流进程

以前学的都是单执行流，执行流PCB本身也属于进程内部的资源。
线程是调度的基本单位。

进程切换的成本非常的高，但是进程和线程在CPU中看到的是一样的。
进程切换，地址空间，页表，包括曾经的数据基本都要切换。

内部的执行流就可以称之为一个线程，也就是说一个进程内部可以有一个或者多个线程，CPU调度时, 看到的基本单位全部都叫做线程。

1.2 线程的创建：

Linux中没有原生创建线程的接口，但是Linux有原生线程库，由应用级程序员帮我们开发出了一批接口，叫做pthread_create。

不是操作系统的接口，叫做原生线程库：

在这里插入图片描述

第一个参数： 是一个输出型参数，在成功创建线程后，这个变量会被用来保留新线程的ID，供后面的操作使用。
第二个参数： 用来设置线程属性的，可以传递一个nullptr指针，表示使用默认线程属性，也可以通过pthread_attr_t类型的变量来设置自定义的属性。
第三个参数： 是一个函数指针，是指向线程运行函数的指针，函数的返回值和参数必须符合线程函数的要求。
第四个参数： 就是第三个参数，函数指针指向的函数的参数。它是一个void类型的指针，可以传递任意类型的数据给线程函数。

注意：

在现在所有主流的Linux版本中，都默认带这个库，是原生的，在操作系统中就存在的。
不是所谓的系统调用接口，是库函数。

创建线程的时候，本质就是让线程执行进程代码的一部分，有一个进程里面有十几个函数，把某一个函数当做该线程的入口函数，让该线程去调度。

CPU看到的所有的task_struct都是一个进程。
CPU看到的所有的task_struct都是一个执行流（线程）

线程是属于某一个进程的，所以不需要创建新的mm_struct和页表映射，但是创建的效率高于创建子进程。创建新线程后（创建新的PCB）只要将task_struct指向所属进程的mm_struct即可。

在进程中，我们谈父子线程，在线程中，我们谈主新线程。

1.3 线程的等待：

在这里插入图片描述
pthread_ join等待线程的理由：

释放线程资源，前提是线程退出了。
获取线程对应的退出码。

线程退出的时候，一般必须要进行join，如果不进行join：

就会造成类似于进程那样的内存泄漏的问题（没有僵尸线程这样的说法）
线程对应的退出结果暂时不获取

返回值：

在这里插入图片描述

pthread_join第二个参数的理解：

是一个输出型参数，获取新线程退出时的退出码。
进程退出的三种情况：
- 代码跑完，结果正确。
- 代码跑完，结果不正确。
- 异常。
线程也是一样，执行流的退出情况也是上述三种情况。

pthread_join第二个参数为什么是二级指针：

因为是一个输出型参数，要改变指针，就要传指针的地址。

主线程为何没有获取新线程退出时的信号？

线程异常了的话，那么整个进程也就直接退出了。
线程异常 == 进程异常
所以也就是说，一个线程会影响其他线程的运行。
线程的健壮性不如进程。

线程出异常了，不再是线程的问题了，而是进程的问题了。所以pthread_join不需要退出信号。

所以以后考虑线程终止，只考虑正常终止。

2. 查看线程

我们来创建两个线程，来分别查看一下进程和线程：

#include <iostream>
#include <string>
#include <unistd.h>
// #include <pthread.h>
#include <thread> // C++11的线程库

using namespace std;

void* callback1(void* args)
{
    string name = (char*)args;
    while (true)
    {
        cout << name << ": " << ::getpid() << endl;
        sleep(1);
    }
}

void* callback2(void* args)
{
    string name = (char*)args;
    while (true)
    {
        cout << name << ": " << ::getpid() << endl;
        sleep(1);
    }
}

int main()
{
    // std::thread t([](){
    //     while(true)
    //     {
    //         cout << "线程运行起来啦" << endl;
    //         sleep(1);
    //     }
    // });

    // 等待就可以了
    // t.join();

    pthread_t tid1;
    pthread_t tid2;

    pthread_create(&tid1, nullptr, callback1, (void*)"thread 1");
    pthread_create(&tid2, nullptr, callback2, (void*)"thread 2");

    while (true)
    {
        cout << "我是主线程...: " << ::getpid() << endl;
        sleep(1);
    }

    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);

    return 0;
}