【Linux跬步积累】—— 线程-优快云博客

本文链接：https://blog.youkuaiyun.com/PH_modest/article/details/144242078

🌏博客主页：PH_modest的博客主页
🚩当前专栏：Linux跬步积累
💌其他专栏：
🔴 每日一题
🟡 C++跬步积累
🟢 C语言跬步积累
🌈座右铭：广积粮，缓称王！

Linux线程概念

什么是线程

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

在这里插入图片描述

需要明确的是，一个进程的创建实际上伴随着其进程控制块（task_struct）、进程地址空间（mm_struct）以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。

在这里插入图片描述
每个进程都有自己独立的进程地址空间和独立的页表，这也就意味着所有进程在运行时本身就具有独立性。

但如果我们在创建“进程”时，只创建task_struct，并要求创建出来的task_struct和父task_struct共享进程地址空间和页表，那么创建的结果就是下面这样的：

在这里插入图片描述
此时其实我们创建的就是四个线程：

其中每个线程都是当前进程的一个执行流，也就是我们常说的“线程是进程内部的一个执行分支”。
同时我们可以看出，线程在进程内部运行，也就是说，进程申请的所有资源，几乎都是被所有线程共享的。

注意： 单纯从技术角度，这个是一定能实现的，因它比创建一个原始进程所做的工作更加轻量化。

该如何重新理解之前的进程？

下面蓝色方框内的，我们称为进程：

在这里插入图片描述
因此，所谓的进程并不是通过task_struct来衡量的，除了task_struct之外，一个进程还要有进程地址空间、文件、信号等等，合起来称之为一个进程。

现在我们应该站在内核角度来理解进程：承担分配系统资源的基本实体，叫做进程。

换言之，当我们创建进程时，就是创建一个task_struct、创建进程地址空间、维护页表，然后在物理地址内开辟空间、构建映射，打开进程默认打开的相关文件、注册信号对应的处理方案等。

而我们之前接触到的进程都只有一个task_struct，也就是该进程内部只有一个执行流，即单执行流进程，反之，内部有多个执行流的进程叫做多执行流进程。

在Linux中，站在CPU的角度，能否识别当前调度的task_struct是进程还是线程？

答案是不能，也不需要，因为CPU只关心一个一个的独立执行流。无论进程内部是有一个执行流还是多个执行流，CPU都是以task_struct为单位调度的。

单执行流进程被调度：

在这里插入图片描述
多执行流进程被调度：

在这里插入图片描述

因此，CPU看到的虽然还是task_struct，但已经比传统的进程要更加轻量化了。

LInux下并不存在真正的多线程！而是用进程模拟的！

操作系统中存在大量进程，一个进程又有一个或多个线程，因此线程的数量一定比进程的数量多，当线程的数量足够多的时候，很明显线程的执行粒度要比进程更细。

如果一款操作系统要支持真的线程，那么就需要对这些线程进行管理，比如说，创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等，所有的这一套比较进程都需要另起炉灶，搭建一套与之平行的线程管理模块。

因此，如果要支持真的线程，一定会提高设计操作系统的复杂度。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。

但也有支持线程的操作系统，比如Windows操作系统，因此Windows操作系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂的多。

既然在Linux没有真正意义的线程，那么也就绝对没有真正意义上的线程相关的系统调用！

这就很好理解了，既然在Linux中都没有真正意义上的线程，那么自然也就没有真正意义上的线程相关的系统调用了。但是Linux可以提供创建轻量级进程的接口，也就是创建进程，共享空间，其中最典型的代表就是vfork函数。

vfork函数的功能就是创建子进程，但是父子共享空间，vfork的函数原型如下：

pid_t vfork(void);

vfork函数的返回值与fork函数的返回值相同：

给父进程返回子进程的PID。
给子进程返回0。

只不过vfork创建出来的子进程与父进程共享地址空间，例如下面的代码，子进程将全局变量g_val由100改成了200，父进程休眠3秒后再读取全局变量的值，观察一下输出的结果。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int g_val = 100;
int main()
{
   
   
	pid_t id = vfork();
	if (id == 0){
   
   
		//child
		g_val = 200;
		printf("child:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);
		exit(0);
	}
	//father
	sleep(3);
	printf("father:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);
	return 0;
}

可以看到，父进程读取到g_val的值是子进程修改后的值，也就证明了vfork创建的子进程与其父进程是共享地址空间。

在这里插入图片描述

原生线程库pthread

在Linux中，站在内核角度没有真正意义上线程相关的接口，但是站在用户角度，当用户想创建一个线程时更希望使用thread_create这样类似的接口，而不是vfork函数，因此系统为用户层提供了原生线程库pthread。

原生线程库实际上就是对轻量级进程系统调用的封装，在用户层面模拟实现了一套线程相关的接口。

因此对于我们来讲，在LInux下学习线程实际上就是学习在用户层模拟实现这一套接口，而并非操作系统的接口。

二级页表

以32位平台为例，在32位平台下一个有2³²个地址，也就意味着有2³²个地址需要被映射。

如果页表只是单纯的一张表，那么它就需要存储2³²个虚拟地址和物理地址的映射关系：

在这里插入图片描述

每一个页表除了有虚拟地址和物理地址之间的映射外，还需要一些和权限有关的信息，比如我们所说的用户级页表和内核级页表，实际就是通过权限进行区分的。

在这里插入图片描述

但如果只有页表只有一张表，需要存储的空间过于大，内存无法存储这样的页表。

因此我们所说的页表并不是一张表。

在二级页表结构中，页表被分为两个层次：

外层页表（Page Directory）：这个层级的页表包含指向内层页表的指针。每个条目（通常称为页目录项）指向一个内层页表。
内层页表（Page Table）：这个层级的页表包含实际的页表项，这些页表项将虚拟页号映射到物理页号。

当进行地址转换时，处理器首先使用虚拟地址中的高位索引外层页表，找到对应的内层页表的地址。然后，处理器使用虚拟地址中的中间位索引这个内层页表，找到对应的页表项，该页表项包含了物理页号。最后，处理器使用虚拟地址中的低位来确定页内偏移量，将物理页号和页内偏移量组合起来形成完整的物理地址。

在这里插入图片描述

注意： 在Linux中，32位平台下用的是二级页表，而64位平台下用的是多级页表。

修改常量字符串为什么会触发段错误？

当我们要修改一个常量字符串时，虚拟地址必须经过页表映射找到对应的物理内存，而在查表过程中发现其权限是只读，你想对其进行修改，就会在MMU内部触发硬件错误，操作系统在识别到是哪一个进程导致的之后，就会给该进程发送信号将其进行终止。

线程的优点：

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

如何理解创建一个新线程的代价要比创建一个新进程小的多？

线程由于共享进程的资源，因此在创建和维护上的成本比进程要低。这使得线程适合于需要大量并发但资源共享的场景，而进程则更适合于需要独立资源和错误隔离的场景。

如何理解与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多？

线程之间的切换由于共享相同的地址空间和资源，需要操作系统做的工作比进程之间的切换要少很多，这使得线程切换更加高效。

如何理解计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现？

计算密集型应用是指那些主要依赖于CPU计算资源来完成其任务的应用程序，比如科学计算、图像处理、大数据分析、机器学习训练等。这类应用通常需要进行大量的数学运算和逻辑处理，对处理器的性能要求较高。在多处理器系统上运行计算密集型应用时，将计算分解到多个线程中实现，可以提高程序的执行效率和响应速度。

如何理解I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同I/O操作？

I/O密集型应用主要是指那些大部分时间都在等待I/O操作（如磁盘读写、网络通信等）完成的程序。这类应用的特点是CPU占用率相对较低，因为它们花费大量时间在等待I/O操作的完成。为了提高这类应用的性能，通常会采用多线程的策略来提高系统的相应速度。

线程的缺点

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

线程异常

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

线程用途

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

线程私有

线程的硬件上下文（CPU寄存器的值）（调度）
线程的独立栈结构（常规运行）

线程共享

代码和全局变量
进程文件描述符表

线程安全问题

一个线程出问题，导致其他线程也出了问题，导致整个进程退出，这叫做线程安全问题。

函数重入

多线程中，公共函数如果被多个线程同时进入，说明该函数被重入了。

Linux进程 VS 线程

进程和线程

进程是承担分配系统资源的基本实体，线程是调度的基本单位。

线程共享进程数据，但也拥有自己的一部分数据：

线程ID
一组寄存器（存储每个线程的上下文信息）
栈（每个线程都有临时数据，需要压栈出栈）
errno（C语言提供的全局变量，每个线程都有自己的）
信号屏蔽字
调度优先级

进程的多个线程共享

同一地址空间，因此Text Segment、Data Segment都是共享的：

如果定义一个函数，在各线程中都可以调用
如果定义一个全局变量，在各线程中都可以访问到

除此之外，各线程还共享一下进程资源和环境：

文件描述符表（进程打开一个文件后，其他线程也能够看到）
每种信号的处理方式（SIG_IGN、SIG_DFL或者自定义的信号处理函数）
当前工作目录
用户ID和组ID

进程和线程的关系

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

在这里插入图片描述

Linux线程控制

POSIX线程库

与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的。
要使用这些函数库，要通过引入头文件<pthread.h>
链接这些线程函数库时要使用编译器命令的“-lpthread”选项。
pthread线程库是应用层的原生线程库，应用层指的是这个线程库并不是系统接口直接提供的，而是由第三方帮我们提供的。原生指的是大部分Linux系统都会默认带上该线程库。

创建线程

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

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；失败返回错误码

错误检查：

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

让主线程创建一个新线程

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

主线程是产生其他子线程的线程。
通常主线程最后需要执行某些操作，例如各种关闭动作。

下面我们让主线程调用pthread_create函数来创建一个子线程，然后子线程就会去执行自己的代码，而主线程也会继续往后执行。

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

void* Routine(void* arg)
{
   
   
    char* msg=(char*)arg;
    while(1)
    {
   
   
        printf("I am %s\n",msg);
        sleep(1);
    }
}

int main()
{
   
   
    pthread_t tid;
    pthread_create(&tid,NULL,Routine,(void*)"thread 1");
    while(1)
    {
   
   
        printf("I am main thread!\n");
        sleep(2);
    }
    return 0;
}

运行结果如下：
在这里插入图片描述

当我们用ps axj命令查看当前进程的信息时，虽然此时该进程中有两个线程，但我们看到的进程只有一个，因为这两个线程都是属于这个进程的。

在这里插入图片描述
如果想看进程内的轻量级进程，可以使用ps -aL命令，可以显示当前的轻量级进程。

默认情况下，不带-L，看到的就是一个个进程。
带-L就可以查看到每个进程内的多个轻量级进程。

在这里插入图片描述
其中，LWP（Light Weight Process）就是轻量级进程的ID，可以看到显示的两个轻量级进程的PID是相同的，因为他们属于同一个进程。

注意： 在Linux中，应用层的线程与内核的LWP是一一对应的，实际上操作系统调度的时候采用的是LWP，而并非PID，只不过之前我们都是单线程进程，其PID和LWP的值是相同的，所以对于单线程进程来说，调度时采用PID和LWP是一样的。

为了进一步验证两个线程是属于同一个进程的，我们可以让主线程和子线程在进行操作时，打印各自的pid和ppid，通过pid和ppid就可以很明确的判断了。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>

void* routine(void* arg)
{
   
   
    char* msg=(char*)arg;
    while(1)
    {
   
   
        printf("I am %s,pid:%d,ppid:%d\n",msg,getpid(),getppid());
        sleep(1);
    }
}

int main()
{
   
   
    pthread_t tid;
    pthread_create(&tid,NULL,routine,(void*)"thread 1");
    while(1)
    {
   
   
        printf("I am main thread,pid:%d,ppid:%d\n",getpid(),getppid());
        sleep(2);
    }
    return 0;
}