🌈 个人主页：Zfox_
🔥 系列专栏：Linux
目录
- [一：🔥 线程基本概念](#一：🔥 线程基本概念)
-
- [🦋 1-1 什么是线程](#🦋 1-1 什么是线程)
- [🦋 1-2 分⻚式存储管理](#🦋 1-2 分⻚式存储管理)
-
- [1-2-1 虚拟地址和⻚表的由来](#1-2-1 虚拟地址和⻚表的由来)
- [1-2-2 ⻚表](#1-2-2 ⻚表)
- [1-2-3 ⻚⽬录结构](#1-2-3 ⻚⽬录结构)
- [1-2-4 两级⻚表的地址转换](#1-2-4 两级⻚表的地址转换)
- [1-2-5 缺⻚异常](#1-2-5 缺⻚异常)
- [🦋 1-3 线程的优点](#🦋 1-3 线程的优点)
- [🦋 1-4 线程的缺点](#🦋 1-4 线程的缺点)
- [二：🔥 Linux进程VS线程](#二：🔥 Linux进程VS线程)
-
- [🦋 2-1 进程和线程](#🦋 2-1 进程和线程)
- [🦋 2-2 进程的多个线程共享](#🦋 2-2 进程的多个线程共享)
- [三：🔥 Linux线程控制](#三：🔥 Linux线程控制)
-
- [🦋 3-1 POSIX线程库](#🦋 3-1 POSIX线程库)
- [🦋 3-2 创建线程](#🦋 3-2 创建线程)
- [🦋 3-3 线程终⽌](#🦋 3-3 线程终⽌)
- [🦋 3-4 线程等待](#🦋 3-4 线程等待)
- [🦋 3-5 分离线程](#🦋 3-5 分离线程)
- [四：🔥 线程ID及进程地址空间布局](#四：🔥 线程ID及进程地址空间布局)
- [五：🔥 线程封装](#五：🔥 线程封装)
- 六：🔥线程栈
- [七：🔥 共勉](#七：🔥 共勉)
一：🔥 线程基本概念
🦋 1-1 什么是线程
- 在⼀个程序⾥的⼀个执⾏路线就叫做
线程（thread）。更准确的定义是：线程是"⼀个进程内部的控制序列"。 - ⼀切进程⾄少都有⼀个执⾏线程。
- 在Linux系统中，在CPU眼中，看到的PCB都要⽐传统的进程更加轻量化 。
- 透过进程虚拟地址空间，可以看到进程的⼤部分资源，将进程资源合理分配给每个执⾏流，就形成了线程执⾏流 。
- 对于内核来说，
线程是CPU调度的基本单位，进程是承担分配系统资源的基本实体。 Linux内核中，没有真正意义上的线程，是复用PCB(进程控制块）模拟线程的TCB。- 进程是包含内部所有的 task_struct，虚拟地址空间，页表，以及内存中的代码数据。
- 对于 CPU 来讲，它并不能区分轻量级进程(线程在 Linux 下的叫法)还是单独的 task_struct (传统的进程)
- 对于 OS 来讲，它能通过 pid 来区别进程，用 LWP 来区分线程。
- 当 CPU 要执行线程时，不需要将进程的上下文以及虚拟地址空间、页表进行更换，并且有 cache 的局部性原理，不需要更换数据。
🦋 1-2 分⻚式存储管理
1-2-1 虚拟地址和⻚表的由来
🦁 思考⼀下，如果在没有虚拟内存和分⻚机制的情况下，每⼀个用户程序在物理内存上所对应的空间必须是连续的，如下图：
因为每⼀个程序的代码、数据⻓度都是不⼀样的，按照这样的映射⽅式，物理内存将会被分割成各种离散的、⼤⼩不同的块。经过⼀段运⾏时间之后，有些程序会退出，那么它们占据的物理内存空间可以被回收，导致这些物理内存都是以很多**碎⽚**的形式存在。
怎么办呢？我们希望操作系统提供给⽤⼾的空间必须是连续的，但是物理内存最好不要连续。此时虚拟内存和分⻚便出现了，如下图所⽰：
把物理内存按照⼀个固定的⻓度的⻚框进⾏分割，有时叫做物理⻚。每个⻚框包含⼀个物理⻚（page）。⼀个⻚的⼤⼩等于⻚框的⼤⼩。⼤多数 32位 体系结构⽀持 4KB 的⻚，⽽ 64位 体系结构⼀般会⽀持 8KB 的⻚。区分⼀⻚和⼀个⻚框是很重要的：
- 🌳 ⻚框是⼀个存储区域。
- 🌳 ⽽⻚是⼀个数据块，可以存放在任何⻚框或磁盘中。
有了这种机制，CPU 便并⾮是直接访问物理内存地址，⽽是通过虚拟地址空间来间接的访问物理内存地址。所谓的虚拟地址空间，是操作系统为每⼀个正在执⾏的进程分配的⼀个逻辑地址，在32位机上，其范围从0 ~ 4G-1。
- 操作系统通过将虚拟地址空间和物理内存地址之间建⽴映射关系，也就是⻚表，这张表上记录了每⼀对⻚和⻚框的映射关系，能让CPU间接的访问物理内存地址。
🦁 总结⼀下，其思想是将虚拟内存下的逻辑地址空间分为若⼲⻚，将物理内存空间分为若⼲⻚框，通过⻚表便能把连续的虚拟内存，映射到若⼲个不连续的物理内存⻚。这样就解决了使⽤连续的物理内存造成的碎⽚问题。
1-2-2 ⻚表
⻚表中的每⼀个表项，指向⼀个物理⻚的开始地址。在 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 个⻚表就⾜够了。
计算过程：
每⼀个⻚表项指向⼀个 4KB 的物理⻚，那么⼀个⻚表中 1024 个⻚表项，⼀共能覆盖 4MB 的物理内存; 那么 10MB 的程序，向上对⻬取整之后(4MB 的倍数，就是 12 MB)，就需要 3 个⻚表就可以了。
1-2-3 ⻚⽬录结构
到⽬前为⽌，每⼀个⻚框都被⼀个⻚表中的⼀个表项来指向了，那么这 1024 个⻚表也需要被管理起来。管理⻚表的表称之为⻚⽬录表，形成⼆级⻚表。如下图所⽰：
- 所有⻚表的物理地址被⻚⽬录表项指向
- ⻚⽬录的物理地址被 CR3 寄存器 指向，这个寄存器中，保存了当前正在执⾏任务的⻚⽬录地址。
所以操作系统在加载⽤⼾程序的时候，不仅仅需要为程序内容来分配物理内存，还需要为⽤来保存程序的⻚⽬录和⻚表分配物理内存。
1-2-4 两级⻚表的地址转换
下⾯以⼀个逻辑地址为例。将逻辑地址（ 0000000000,0000000001,11111111111 ）转换为物理地址的过程：
- 在32位处理器中，采⽤4KB的⻚⼤⼩，则虚拟地址中低12位为⻚偏移，剩下⾼20位给⻚表，分成两级，每个级别占10个bit（10+10）。
- CR3 寄存器 读取⻚⽬录起始地址，再根据⼀级⻚号查⻚⽬录表，找到下⼀级⻚表在物理内存中存放位置。
- 根据⼆级⻚号查表，找到最终想要访问的内存块号。
- 结合⻚内偏移量得到物理地址
- 注：⼀个物理⻚的地址⼀定是 4KB 对⻬的(最后的 12 位全部为 0 )，所以其实只需要记录物理⻚地址的⾼ 20 位即可。
- 以上其实就是 MMU 的⼯作流程。MMU(Memory Manage Unit)是⼀种硬件电路，其速度很快，主要⼯作是进⾏内存管理，地址转换只是它承接的业务之⼀。
到这⾥其实还有个问题，MMU要先进⾏两次⻚表查询确定物理地址，在确认了权限等问题后，MMU再将这个物理地址发送到总线，内存收到之后开始读取对应地址的数据并返回。那么当⻚表变为N级时，就变成了N次检索+1次读写。可⻅，⻚表级数越多查询的步骤越多，对于CPU来说等待时间越⻓，效率越低。
让我们现在总结⼀下：单级⻚表对连续内存要求⾼，于是引⼊了多级⻚表，但是多级⻚表也是⼀把双刃剑，在减少连续存储要求且减少存储空间的同时降低了查询效率。
有没有提升效率的办法呢？计算机科学中的所有问题，都可以通过添加⼀个中间层来解决。 MMU 引⼊了新武器，江湖⼈称快表的 TLB （其实，就是缓存）
当 CPU 给 MMU 传新虚拟地址之后， MMU 先去问 TLB 那边有没有，如果有就直接拿到物理地址发到总线给内存，⻬活。但 TLB 容量⽐较⼩，难免发⽣ Cache Miss ，这时候 MMU 还有保底的⽼武器 ⻚表，在⻚表中找到之后 MMU 除了把地址发到总线传给内存，还把这条映射关系给到TLB，让它记录⼀下刷新缓存。
1-2-5 缺⻚异常
设想，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 错误中断进程直接挂掉。
🦋 1-3 线程的优点
- 创建⼀个新线程的代价要⽐创建⼀个新进程⼩得多。
- 与进程之间的切换相⽐，线程之间的切换需要操作系统做的⼯作要少很多。
-
- 最主要的区别是
线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上下⽂切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。
- 最主要的区别是
-
- 另外⼀个隐藏的损耗是
上下⽂的切换会扰乱处理器的缓存机制。简单的说，⼀旦去切换上下⽂，处理器中所有已经缓存的内存地址⼀瞬间都作废了。还有⼀个显著的区别是当你改变虚拟内存空间的时候，处理的⻚表缓冲 TLB （快表）会被全部刷新，这将导致内存的访问在⼀段时间内相当的低效。但是在线程的切换中，不会出现这个问题，当然还有 硬件 cache。
- 另外⼀个隐藏的损耗是
- 线程占⽤的资源要⽐进程少很。
- 能充分利⽤多处理器的可并⾏数量。
- 在等待慢速 I/O 操作结束的同时，程序可执⾏其他的计算任务 。
- 计算密集型应⽤，为了能在多处理器系统上运⾏，将计算分解到多个线程中实现。
- I/O 密集型应⽤，为了提⾼性能，将 I/O 操作重叠。线程可以同时等待不同的 I/O 操作。
🦋 1-4 线程的缺点
- 性能损失
-
- ⼀个很少被外部事件阻塞的计算密集型线程往往⽆法与其它线程共享同⼀个处理器。如果计算密集型线程的数量⽐可⽤的处理器多，那么可能会有较⼤的性能损失，这⾥的性能损失指的是增加了额外的同步和调度开销，⽽可⽤的资源不变。
- 健壮性降低
-
- 编写多线程需要更全⾯更深⼊的考虑，在⼀个多线程程序⾥，因时间分配上的细微偏差或者因共享了不该共享的变量⽽造成不良影响的可能性是很⼤的，换句话说线程之间是缺乏保护的。
- 缺乏访问控制
-
- 进程是访问控制的基本粒度，在⼀个线程中调⽤某些OS函数会对整个进程造成影响。
- 编程难度提⾼
二：🔥 Linux进程VS线程
🦋 2-1 进程和线程
- 进程是资源分配的基本单位
- 线程是调度的基本单位
- 线程共享进程数据，但也拥有⾃⼰的⼀部分数据:
-
- 线程ID
-
- ⼀组寄存器
-
- 栈
-
- errno
-
- 信号屏蔽字
-
- 调度优先级
🦋 2-2 进程的多个线程共享
同⼀地址空间,因此Text Segment、Data Segment都是共享的,如果定义⼀个函数,在各线程中都可以调⽤,如果定义⼀个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:
- ⽂件描述符表
- 每种信号的处理⽅式(SIG_ IGN、SIG_ DFL或者⾃定义的信号处理函数)
- 当前⼯作⽬录
- ⽤⼾id和组id
进程和线程的关系如下图:
如何看待之前学习的单进程？具有⼀个线程执⾏流的进程！
三：🔥 Linux线程控制
🦋 3-1 POSIX线程库
- 与线程有关的函数构成了⼀个完整的系列，绝⼤多数函数的名字都是以 "pthread_" 打头的
- 要使⽤这些函数库，要通过引⼊头⽂件 <pthread.h>
- 链接这些线程函数库时要使⽤编译器命令的 "-lpthread" 选项
🦋 3-2 创建线程
cpp
功能：创建⼀个新的线程
原型：
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，并且对全局变量 errno 赋值以指⽰错误。
- pthreads 函数出错时不会设置全局变量 errno（⽽⼤部分其他 POSIX 函数会这样做）。⽽是将错误代码通过返回值返回
- pthreads 同样也提供了线程内的 errno 变量，以⽀持其它使⽤ errno 的代码。对于 pthreads 函数的错误，建议通过返回值业判定，因为读取返回值要⽐读取线程内的 errno 变量的开销更⼩
cpp
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *rout(void *arg)
{
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);
}
for (;;)
{
printf("I'am main thread\n");
sleep(1);
}
return 0;
}
输出：
I'am main thread
I'am thread 1
cpp
#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命令查看线程信息
运⾏代码后执⾏：
cpp
$ 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 线程终⽌
如果需要只终⽌某个线程⽽不终⽌整个进程,可以有三种⽅法:
- 从线程函数return。这种⽅法对主线程不适⽤,从main函数return相当于调⽤exit。
- 线程可以调⽤pthread_ exit终⽌⾃⼰。
- ⼀个线程可以调⽤pthread_ cancel终⽌同⼀进程中的另⼀个线程。
pthread_exit 函数
cpp
功能：线程终⽌
原型:
void pthread_exit(void *value_ptr);
参数:
value_ptr:value_ptr不要指向⼀个局部变量。
返回值：
⽆返回值，跟进程⼀样，线程结束的时候⽆法返回到它的调⽤者（⾃⾝）需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是⽤malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。
pthread_cancel 函数
cpp
功能：取消⼀个执⾏中的线程
原型:
int pthread_cancel(pthread_t thread);
参数:
thread:线程ID
返回值：成功返回0；失败返回错误码🦋 3-4 线程等待
为什么需要线程等待？
- 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
- 创建新的线程不会复⽤刚才退出线程的地址空间。
cpp
功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数:
thread:线程ID
value_ptr:它指向⼀个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码调⽤该函数的线程将挂起等待,直到 id 为 thread 的线程终⽌。thread 线程以不同的⽅法终⽌,通过 pthread_join 得到的终⽌状态是不同的，总结如下:
- 如果 thread 线程通过 return 返回, value_ ptr 所指向的单元⾥存放的是 thread 线程函数的返回值。
- 如果 thread 线程被别的线程调⽤ pthread_ cancel 异常终掉, value_ ptr 所指向的单元⾥存放的是常
数 PTHREAD_ CANCELED。 - 如果 thread 线程是⾃⼰调⽤ pthread_exit 终⽌的, value_ptr 所指向的单元存放的是传给 pthread_exit 的参数。
- 如果对 thread 线程的终⽌状态不感兴趣,可以传 NULL 给 value_ ptr 参数。
cpp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread1(void *arg)
{
printf("thread 1 returning ... \n");
int *p = (int *)malloc(sizeof(int));
*p = 1;
return (void *)p;
}
void *thread2(void *arg)
{
printf("thread 2 exiting ...\n");
int *p = (int *)malloc(sizeof(int));
*p = 2;
pthread_exit((void *)p);
}
void *thread3(void *arg)
{
while (1)
{ //
printf("thread 3 is running ...\n");
sleep(1);
}
return NULL;
}
int main(void)
{
pthread_t tid;
void *ret;
// thread 1 return
pthread_create(&tid, NULL, thread1, NULL);
pthread_join(tid, &ret);
printf("thread return, thread id %X, return code:%d\n", tid, *(int *)ret);
free(ret);
// thread 2 exit
pthread_create(&tid, NULL, thread2, NULL);
pthread_join(tid, &ret);
printf("thread return, thread id %X, return code:%d\n", tid, *(int *)ret);
free(ret);
// thread 3 cancel by other
pthread_create(&tid, NULL, thread3, NULL);
sleep(3);
pthread_cancel(tid);
pthread_join(tid, &ret);
if (ret == PTHREAD_CANCELED)
printf("thread return, thread id %X, return code:PTHREAD_CANCELED\n",tid);
else
printf("thread return, thread id %X, return code:NULL\n", tid);
return 0;
}输出：
cpp
[root@localhost linux]# ./a.out
thread 1 returning ...
thread return, thread id 5AA79700, return code:1
thread 2 exiting ...
thread return, thread id 5AA79700, return code:2
thread 3 is running ...
thread 3 is running ...
thread 3 is running ...
thread return, thread id 5AA79700, return code:PTHREAD_CANCELED🦋 3-5 分离线程
- 默认情况下，新创建的线程是 joinable 的，线程退出后，需要对其进⾏ pthread_join 操作，否则⽆法释放资源，从⽽造成系统泄漏。
- 如果不关⼼线程的返回值，join 是⼀种负担，这个时候，我们可以告诉系统，当线程退出时，⾃动释放线程资源。
cpp
int pthread_detach(pthread_t thread);可以是线程组内其他线程对⽬标线程进⾏分离，也可以是线程⾃⼰分离:
cpp
pthread_detach(pthread_self());joinable和分离是冲突的，⼀个线程不能既是joinable⼜是分离的。
cpp
#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, (void*)"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;
}输出：
cpp
thread1 run...
pthread wait failed四：🔥 线程ID及进程地址空间布局
- pthread_ create函数会产⽣⼀个线程ID，存放在第⼀个参数指向的地址中。该线程ID和前⾯说的线程ID不是⼀回事。
- 前⾯讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最⼩单位，所以需要⼀个数值来唯⼀表⽰该线程。
- pthread_ create函数第⼀个参数指向⼀个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
- 线程库NPTL提供了pthread_ self函数，可以获得线程⾃⾝的ID：
cpp
pthread_t pthread_self(void);pthread_t 到底是什么类型呢？取决于实现。对于Linux⽬前实现的NPTL实现⽽⾔，pthread_t类型的线程ID，本质就是⼀个进程地址空间上的⼀个地址。
五：🔥 线程封装
Thread.hpp
cpp
#ifndef _THREAD_HPP__
#define _THREAD_HPP__
#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>
#include <sys/types.h>
#include <unistd.h>
namespace ThreadModule
{
using func_t = std::function<void()>;
static int number = 1;
enum class TSTATUS
{
NEW,
RUNNING,
STOP
};
class Thread
{
private:
// 成员方法 this
static void *Routine(void *args)
{
Thread *t = static_cast<Thread *>(args); // 传入this指针
t->_status = TSTATUS::RUNNING;
t->_func();
return nullptr;
}
void EnableDetach() { _joinable = false; }
public:
Thread(func_t func)
: _func(func), _status(TSTATUS::NEW), _joinable(true)
{
_name = "Thread-" + std::to_string(number++);
_pid = getpid();
}
bool Start()
{
if (_status != TSTATUS::RUNNING)
{
int n = ::pthread_create(&_tid, nullptr, Routine, this);
if (n != 0)
return false;
return true;
}
return false;
}
bool Stop()
{
if (_status == TSTATUS::RUNNING)
{
int n = ::pthread_cancel(_tid);
if (n != 0)
return false;
_status = TSTATUS::STOP;
return true;
}
return false;
}
bool Join()
{
if (_joinable)
{
int n = ::pthread_join(_tid, nullptr);
if (n != 0)
return false;
_status = TSTATUS::STOP;
return true;
}
return false;
}
void Detach()
{
EnableDetach();
pthread_detach(_tid);
}
bool IsJoinable() { return _joinable; }
std::string Name() { return _name; }
~Thread()
{
}
private:
std::string _name;
pthread_t _tid;
pid_t _pid;
bool _joinable; // 是否是分离的，默认不是
func_t _func;
TSTATUS _status;
};
}
#endif
cpp
#include "Thread.hpp"
#include <unordered_map>
#include <memory>
#define NUM 10
using thread_ptr_t = std::shared_ptr<ThreadModule::Thread>;
int main()
{
// 先描述，再组织！
std::unordered_map<std::string, thread_ptr_t> threads;
// 创建多线程
for (int i = 0; i < NUM; i++)
{
thread_ptr_t t = std::make_shared<ThreadModule::Thread>([](){
while(true)
{
std::cout << "hello world" << std::endl;
sleep(1);
}
});
threads[t->Name()] = t;
}
for(auto &thread:threads)
{
thread.second->Start();
}
for(auto &thread:threads)
{
thread.second->Join();
}
return 0;
}
cpp
// 运⾏结果查询
$ ps -aL
PID LWP TTY TIME CMD
195828 195828 pts/1 00:00:00 main
195828 195829 pts/1 00:00:00 Thread-0
195828 195830 pts/1 00:00:00 Thread-1六：🔥线程栈
虽然 Linux 将线程和进程不加区分的统⼀到了 task_struct ，但是对待其地址空间的 stack 还是
有些区别的。
- 对于 Linux 进程或者说主线程，简单理解就是main函数的栈空间，在fork的时候，实际上就是复制了⽗亲的 stack 空间地址，然后写时拷⻉(cow)以及动态增⻓。如果扩充超出该上限则栈溢出会报段错误（发送段错误信号给该进程）。进程栈是唯⼀可以访问未映射⻚⽽不⼀定会发⽣段错误⸺超出扩充上限才报。
- 然⽽对于主线程⽣成的⼦线程⽽⾔，其 stack 将不再是向下⽣⻓的，⽽是事先固定下来的。线程栈⼀般是调⽤glibc/uclibc等的 pthread 库接⼝ pthread_create 创建的线程，在⽂件映射区（或称之为共享区）。其中使⽤ mmap 系统调⽤，这个可以从 glibc 的 nptl/allocatestack.c 中的 allocate_stack 函数中看到：
cpp
mem = mmap (NULL, size, prot,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);此调⽤中的 size 参数的获取很是复杂，你可以⼿⼯传⼊stack的⼤⼩，也可以使⽤默认的，⼀般⽽⾔就是默认的 8M 。这些都不重要，重要的是，这种stack不能动态增⻓，⼀旦⽤尽就没了，这是和⽣成进程的fork不同的地⽅。在glibc中通过mmap得到了stack之后，底层将调⽤ sys_clone 系统调⽤：
cpp
int sys_clone(struct pt_regs *regs)
{
unsigned long clone_flags;
unsigned long newsp;
int __user *parent_tidptr, *child_tidptr;
clone_flags = regs->bx;
// 获取了mmap得到的线程的stack指针
newsp = regs->cx;
parent_tidptr = (int __user *)regs->dx;
child_tidptr = (int __user *)regs->di;
if (!newsp)
newsp = regs->sp;
return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr);
}因此，对于⼦线程的 stack ，它其实是在进程的地址空间中map出来的⼀块内存区域，原则上是线程私有的，但是同⼀个进程的所有线程⽣成的时候，是会浅拷⻉⽣成者的 task_struct 的很多字段，如果愿意，其它线程也还是可以访问到的，于是⼀定要注意。
七：🔥 共勉
以上就是我对 【linux】线程概念与控制 的理解，觉得这篇博客对你有帮助的，可以点赞收藏关注支持一波~😉
