一文搞懂Linux多线程【上】

🚩引言

今天，我们开始学习Linux中的线程部分。Linux线程和进程同等重要。接下来，我们将从什么是线程，线程的实现原理，为社么会有线程这个概念，线程和进程之间的关系等等方面来学习。我想告诉大家的是线程内容比较困难，希望大家克服困难。那么我们就开始吧！

🚩再次理解页表

在Linux中，我们对页表的概念日益丰富。从一开始的认为页表仅仅负责物理内存和虚拟内存地址之间的转化，然后又知道了不仅仅有用户级页表，也有内核级页表。但是，我们始终不知道页表是如何实现虚拟内存到物理内存之间的地址的转化的。今天，我们就把页表给研究透彻。

在磁盘中，代码被编译时，是按4KB空间大小为单位进行编译的，然后划分出了一个个单位大小的页帧。当代码和数据被加载到内存时，同样也是按照4KB为单位进行加载的。物理内存就划分出了若干个4KB大小的子空间，叫做页框。

这些页框也需要被操作系统给管理起来，管理方法为先描述，再组织。这块内容我就不详细阐述了，大家有兴趣的可以上网查一查。

我们以32位环境为例讲解。

在32位环境下，一个地址是32个比特位，这32个比特位从高权重开始被划分成了10,10,12的三组。

为什么要划分开呢？为什么要这么划分呢？我知道此时的大家心里一定有很多的疑惑，没关系，我们接着往下看。我想告诉大家：世界上的所有东西，都有它存在的理由。

我们先看第一组的10个比特位。这10个比特位表示的十进制数据范围为0----1023，共1014个数据。 这10个比特位对应的是页目录。

这个页目录有1024个空间，把上面的10个比特位的十进制数据当作偏移量，由高到低在页目录中查找。每个空间后面都对应着一张页表。

然后再看第二组的10个比特位，全排列的个数位1024个。我们可以把页表当作一个有1024个元素的数组，里边存放的是物理内存指定页框的起始地址。我们根据偏移量找到起始地址。然后就直接找到了物理内存。

然后到了最后的一组的12个比特位，12个比特位正好对应的是4KB页框的空间呀。我们根据这12个比特位的为地址，就在指定的页框中找到了我们要的数据。

总结一下，过程就是划分虚拟地址的比特位采用多级页表的方式进行查找的。

🚩初识线程

我们先回忆一下进程的概念

我们知道：进程=内核数据结构+进程对应的代码和数据，一个进程的创建必然伴随着大量的数据结构来维护该进程，线程是不是也是这样呢？我们一会儿再谈。

此时的我们应如何看待虚拟内存呢？虚拟内存决定了进程看到的资源。

接下来，我们正式开始介绍我们的线程

如下图：

这就是一个进程的完整的结构。

此时，如果仅创建若干个task_struct结果体，让该结构体指向同一个虚拟内存空间，就形成了若干个执行流，每个执行流就是一个线程。所以，线程是进程内的一个执行流 。原来的一个进程的资源可以按照某种方式划分成若干份，每个线程获得其中的一小份资源。

因为我们采用虚拟内存空间+页表的方式对资源进行划分。所以单个“进程”一定要比之前的进程执行力度更细。

为了方便大家理解，我举个小例子：

一个人被锁到了一件屋子里，这个人仅可以通过窗户看到外边的风景。有一天，又有几个人被关了进来。他们就平分这个窗户，每个人获得其中的一小部分，只可以通过这一小块窗户看到外边。人就是线程，窗户就是页表，外表的风景就是物理内存空间也就是资源。

操作系统作为软硬件资源的管理者，要不要对这些线程进行有效的管理呢？当然需要，管理的方式就是先描述，再组织。

线程之间的关系如何表示，如何表示线程。操作系统如何选择线程进行执行。一切的一切都需要重新构建，其构建过程相当之复杂。所以有的操作系统对线程重新构建了一套数据结构。这样做的操作系统典型的是windows。

但是仔细观察我们不难知道:进程和线程的大多数属性是一样的，为了减少开发的成本和维护成本，我们为何不复用进程的相关数据结构呢？所以操作系统就基于进程的PCB结构体创建了线程的TCB(thread control block)。这样做的操作系统典型的就是Linux。所以对一个进程内的线程的管理就变成了对TCB的管理。

这个结构体，我们先见一见就可以了，里边的东西我们会陆续知道的。

一句话：线程在进程内部运行，线程在进程的地址空间中运行，拥有该进程的一部分资源。

学到现在，懵了。我们有必要再重新认识一下进程

什么是进程？

现在的进程应该包括：若干个PCB和一个虚拟内存空间，若干个页表和物理内存中相关的代码和数据。创建这些结构对象极度依赖系统资源。

所以进程：在内核角度，是承担分配系统资源的基本实体

我们刚刚学了线程，什么是线程呢？

线程就是CPU调度的基本单位，一个线程就是一个执行流。

我们今天讲的进程概念和之前我们学习的进程冲突吗？

毫不冲突。谁规定了一个进程内部必须有多个线程了？一个进程内部有一个执行流（一个执行流就是一个线程）依旧可以。所以我们可以把之前讲的进程认为是单线程的进程。 今天我们认为一个进程包括多个线程，一个进程只有一个线程当然也是可以的。所以之前的进程概念是今天我们学习的进程概念的子集，一个特例。

CPU在调度时，不关系调度的是进程中的哪一个执行流。它所关心的就是让我顺利调度就ok了。

别人给它哪个，它就执行哪个执行流。至于给哪个线程来执行，这是进程应该考虑的问题。

接下来，我们对如上的知识再次总结一下：

1. Linux内核中并没有真正意义上的线程，Linux是使用进程PCB来模拟线程的，是一种完全属于Linux自己的线程方案。
2. 站在CPU的视角，每一个PCB，都是一个轻量级进程。
3. Linux线程是CPU调度的基本单位，而进程是承担分配系统资源的基本单位。
4. 进程是用来整体申请资源的，线程是用来伸手向进程要资源的。
5. Linux中没有真正意义上的线程。但是操作系统只认线程，用户和程序员只认线程。Linux无法提供创建线程的接口，只能提供创建轻量级进程的接口。所以诞生了线程库的概念
6. Linux的这种设计方案好处是什么？一个系统越复杂，也就意味着出问题的概率越高，维护成本也就越高。Linux的设计方案简单，维护成本大大降低，可靠性高。便于长期对外提供服务。

举个小例子：

在我们国家，承担分配社会资源的基本单位就是家庭。一般每个家庭的组成为：子女，父母，爷爷奶奶。子女学习，父母工作。爷爷奶奶可能退休了，他们要管好自己的身体，但是所有人都有一个共同目标，那就是把家里的生活变得越来越好。

国家就像操作系统，家庭像是进程，而每个家庭成员就是线程。但有的人就比较惨了，既无父母，也无子女，这样的家庭既是进程也是线程。

🚩线程和pthread库

pthread是任何Linux的操作系统都必须要有的。

我们提到，在Linux内核中并没有线程这样的概念，自然不会有创建线程的相关系统调用。但是程序员只认线程，所以程序员就自己编写了一个用户级线程库：pthread库

🚀线程创建

在Linux系统中，通过pthread库提供的pthread_create函数可以创建新的线程。该函数的原型如下：

       #include <pthread.h>

       int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);

• thread : 输出型参数，用于获取创建成功线程的ID，该参数是一个输出型参数
• attr（attribute 属性） : 用于设置创建线程的属性，传入NULL设置默认属性
• start_routine（routine 常规） : 该参数是一个函数指针，即线程启动后需要执行的函数
• arg （argument 参数） ： 传给线程的参数

返回值：成功返回0，失败返回-1，错误原因被设置。

当一个程序启动时，一个进程被操作系统进行创建，与此同时一个线程也立刻运行，这个第一个被创建的线程就是主线程。

即主线程就是产生其它子线程的线程，通常主线程必须最后完成某些执行操作，比如各种关闭动作

接下来，我们做一个小实验

#include<pthread.h>
#include<iostream>
#include<unistd.h>
#include<cassert>
using namespace std;

void* pthread_routine(void *args)
{
    while(1)
    {
         cout<<"我是新进程,我正在运行"<<endl;
         sleep(1);
    }
   

}
int main()
{
    pthread_t tid;
    int n=pthread_create(&tid,nullptr,pthread_routine,(void *)"thread one");
    assert(n==0);
    (void)n;

    while(1)
    {
        cout<<"我是主进程,我正在运行"<<endl;
        sleep(1);
    }
    return 0;

}

注意。由于pthread是第三方库，所以我们在编译时，必须指明要链接的库名称。

在Linux中，查看轻量级进程的命令：ps -aL

在查询轻量级进程的查询项中有一个LWP（light weight pthread） 表示轻量级进程的ID。

其中进程的PID和轻量级进程ID相等的线程为主线程，另一个为新线程。它们为两个不同的执行流。

🚩线程的资源共享问题

我们上面谈了，一个线程被创建，被分配得到相应的代码，然后运行。那么数据呢？一个进程内的若干线程的数据是如何保存的呢？我们做个实验

#include<pthread.h>
#include<iostream>
#include<unistd.h>
#include<cassert>
using namespace std;

int g_val=0;
void* pthread_routine(void *args)
{
    while(1)
    {
         cout<<"我是新进程,我正在运行,g_val:"<< g_val++<<"  &g_val: "<<&g_val<<endl;
         sleep(1);
    }
   

}
int main()
{
    pthread_t tid;
    int n=pthread_create(&tid,nullptr,pthread_routine,(void *)"thread one");
    assert(n==0);
    (void)n;

    while(1)
    {
        cout<<"我是主进程,我正在运行,g_val:"<<g_val<<"   &g_val:"<<&g_val<<endl;
        sleep(1);
    }
    return 0;

}

我们定义一个全局变量，然后由新线程对该全局变量进行++操作。从主线程端读取数据。

从中，我们发现新线程将数据一改，主线程立刻就可以读取改过的数据。且主线程和新线程读取的地址是同一个。说明这个变量是被所有进程所共享的。

在进程中，线程一旦被创建，几乎所有的资源都是被所有线程所共享的。但一定也要有线程私有的成分。资源共享对线程来说是优势，同时也是劣势。我们将来要花费很多的时间来解决资源共享带来的一系列问题。

在家庭中，一般我们家庭的资源都是被所有家庭成员所共享的。例如：电视机，交通工具等等。

但是，也肯定存在成员见私有的东西，比如日记本，老年人吃的补品等等。

在线程中，什么资源都是线程所私有的呢？

• PCB属性私有，例如状态优先级。
• 要有一定私有的上下文数据
• 每一个线程都要有独立的栈结构

对于第三点，我有问题，虚拟地址空间中只有一个栈结构，怎样实现独立的呢？我们后边说。

有观点认为，相比于进程切换，线程切换需要操作系统做的工作要小的多。为什么这样说呢？

• 进程切换需要切换：上下文数据&&PCB&&虚拟内存&&切换页表
• 线程切换需要切换：上下文数据&&PCB
• 其主要的差异体现在cache上。线程切换时cache不用太更新，数据依旧可以使用；但是进程在切换时，数据需要全部更新。

其实，CPU是CPU内部的一个硬件级缓存，这个缓存速度比内存要快，但是比CPU运算的速度要慢。从内存中读取的数据要先经过cache，然后寄存器再从cache中读取数据。

一个运行正常的进程，cache中一定存在着大量的热点数据，线程在切换时，同属于一个进程，我们知道一个进程的大部分数据是被所有线程所共享的。所以线程在切换极有可能会继续使用cache中的热点数据。进程在切换时，这些热点数据一点用就没有了，需要全部加载。这些热点数据的形成是需要时间的，这段时间内cpu只能写透式的访问内存，所以操作系统要做更多的工作。

🚩线程的优缺点

优点

• 创建一个新线程的代价要比创建一个新进程小得多
• 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
• 线程占用的资源要比进程少很多
• 能充分利用多处理器的可并行数量
• 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
• 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
• I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

缺点

• 性能损失，一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
• 健壮性降低编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
• 缺乏访问控制进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
• 编程难度提高编写与调试一个多线程程序比单线程程序困难得多

到这，本博客内容就到这里了，我们下期再见！