线程概念与控制

原创 于 2025-04-20 17:21:01 发布 · 681 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #c++ #开发语言 #运维

线程概念与控制

1. Linux线程概念

1.1 什么是线程

  • 在⼀个程序⾥的⼀个执⾏路线就叫做线程（thread）。更准确的定义是：线程是“⼀个进程内部的控制序列”
  • ⼀切进程⾄少都有⼀个执⾏线程
  • 线程在进程内部运⾏，本质是在进程地址空间内运⾏
  • 在Linux系统中，在CPU眼中，看到的PCB都要⽐传统的进程更加轻量化
  • 透过进程虚拟地址空间，可以看到进程的⼤部分资源，将进程资源合理分配给每个执⾏流，就形成了线程执⾏流
  • 线程是cpu调度的基本单位
  • 进程是承担系统资源分配的具体实体
  • 总之在Linux线程实现的方式轻量级进程（我们之前学过的task_stuct其实就是一个轻量级进程，我们之前学的进程可以看做只有一个线程的进程，一个进程可以有多个线程也就是一个进程的多个线程可以访问统一系统资源，因为进程是承担系统资源分配的具体实体，多个线程共享一个进程虚拟地址空间）。

1.2 分页式存储管理

1.2.1 虚拟地址和⻚表的由来

思考⼀下，如果在没有虚拟内存和分⻚机制的情况下，每⼀个⽤⼾程序在物理内存上所对应的空间必须是连续的，如下图：
在这里插入图片描述
因为每⼀个程序的代码、数据⻓度都是不⼀样的，按照这样的映射⽅式，物理内存将会被分割成各种离散的、⼤⼩不同的块。经过⼀段运⾏时间之后，有些程序会退出，那么它们占据的物理内存空间可以被回收，导致这些物理内存都是以很多碎⽚的形式存在。怎么办呢？我们希望操作系统提供给⽤⼾的空间必须是连续的，但是物理内存最好不要连续。此时虚拟内存和分⻚便出现了，如下图所⽰：
在这里插入图片描述
把物理内存按照⼀个固定的⻓度的⻚框进⾏分割，有时叫做物理⻚。每个⻚框包含⼀个物理⻚（page）。⼀个⻚的⼤⼩等于⻚框的⼤⼩。⼤多数 32位 体系结构⽀持 4KB 的⻚，⽽ 64位 体系结
构⼀般会⽀持 8KB 的⻚。区分⼀⻚和⼀个⻚框是很重要的、

  • ⻚框是⼀个存储区域；
  • ⽽⻚是⼀个数据块，可以存放在任何⻚框或磁盘中
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
一页就是我们的虚拟地址空间划分的基本单位（也就是虚拟页），我们可以通过页表把一页映射到我们的页框号，在通过页框号加地址偏移拿到具体的物理地址。一页也可以存储在我们的页框中。一页对应一个页框。
在这里插入图片描述
有了这种机制，CPU 便并⾮是直接访问物理内存地址，⽽是通过虚拟地址空间来间接的访问物理内存地址。所谓的虚拟地址空间，是操作系统为每⼀个正在执⾏的进程分配的⼀个逻辑地址，在32位机上，其范围从0 ~ 4G-1。操作系统通过将虚拟地址空间和物理内存地址之间建⽴映射关系，也就是⻚表，这张表上记录了每⼀对⻚和⻚框的映射关系，能让CPU间接的访问物理内存地址。

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

1.2.2 物理内存管理

内核⽤ struct page 结构表⽰系统中的每个物理⻚，出于节省内存的考虑， struct page 中使⽤了⼤量的联合体union。

/* include/linux/mm_types.h */
struct page {
/* 原⼦标志，有些情况下会异步更新 */
`unsigned long flags;
union {
struct {
/* 换出⻚列表，例如由zone->lru_lock保护的active_list */
struct list_head lru;
/* 如果最低为为0，则指向inode
* address_space，或为NULL
* 如果⻚映射为匿名内存，最低为置位
* ⽽且该指针指向anon_vma对象
*/
struct address_space* mapping;
/* 在映射内的偏移量 */
pgoff_t index;
/*
* 由映射私有，不透明数据
* 如果设置了PagePrivate，通常⽤于buffer_heads
* 如果设置了PageSwapCache，则⽤于swp_entry_t
* 如果设置了PG_buddy，则⽤于表⽰伙伴系统中的阶
*/
unsigned long private;
};
struct { /* slab, slob and slub */
union {
struct list_head slab_list; /* uses lru */
struct { /* Partial pages */
struct page* next;
#ifdef CONFIG_64BIT
int pages; /* Nr of pages left */
int pobjects; /* Approximate count */
#else
short int pages;
short int pobjects;
#endif
};
};
struct kmem_cache* slab_cache; /* not slob */
/* Double-word boundary */
void* freelist; /* first free object */
union {
void* s_mem; /* slab: first object */
unsigned long counters; /* SLUB */
struct { /* SLUB */
unsigned inuse : 16; /* ⽤于SLUB分配器：对象的数⽬ */
unsigned objects : 15;
unsigned frozen : 1;
};
};

其中⽐较重要的⼏个参数：

  1. flags ：⽤来存放⻚的状态。这些状态包括⻚是不是脏的，是不是被锁定在内存中等。flag的每⼀位单独表⽰⼀种状态，所以它⾄少可以同时表⽰出32种不同的状态。这些标志定义在<linux/page-flags.h>中。其中⼀些⽐特位⾮常重要，如PG_locked⽤于指定⻚是否锁定，PG_uptodate⽤于表⽰⻚的数据已经从块设备读取并且没有出现错误。
  2. _mapcount ：表⽰在⻚表中有多少项指向该⻚，也就是这⼀⻚被引⽤了多少次。当计数值变为-1时，就说明当前内核并没有引⽤这⼀⻚，于是在新的分配中就可以使⽤它（也就是一个page可以被多个虚拟页映射相当于共享内存）。
  3. virtual ：是⻚的虚拟地址。通常情况下，它就是⻚在虚拟内存中的地址。有些内存（即所谓的⾼端内存）并不永久地映射到内核地址空间上。在这种情况下，这个域的值为NULL，需要的
    时候，必须动态地映射这些⻚
    在这里插入图片描述

1.2.3 ⻚表

⻚表中的每⼀个表项，指向⼀个物理⻚的开始地址。在 32 位系统中，虚拟内存的最⼤空间是 4GB ，这是每⼀个⽤⼾程序都拥有的虚拟内存空间。既然需要让 4GB 的虚拟内存全部可⽤，那么⻚表中就需要能够表⽰这所有的 4GB 空间，那么就⼀共需要 4GB/4KB = 1048576 个表项。
在这里插入图片描述
虚拟内存看上去被虚线“分割”成⼀个个单元，其实并不是真的分割，虚拟内存仍然是连续的。这个
虚线的单元仅仅表⽰它与⻚表中每⼀个表项的映射关系，并最终映射到相同⼤⼩的⼀个物理内存⻚上。
⻚表中的物理地址，与物理内存之间，是随机的映射关系，哪⾥可⽤就指向哪⾥(物理⻚)。虽然最终使⽤的物理内存是离散的，但是与虚拟内存对应的线性地址是连续的。处理器在访问数据、获取指令时，使⽤的都是线性地址，只要它是连续的就可以了，最终都能够通过⻚表找到实际的物理地址。在 32 位系统中，地址的⻓度是 4 个字节，那么⻚表中的每⼀个表项就是占⽤ 4 个字节。所以⻚表占据的总空间⼤⼩就是： 1048576*4 = 4MB 的⼤⼩。也就是说映射表⾃⼰本⾝，就要占⽤ 4MB /4KB = 1024 个物理⻚。这会存在哪些问题呢？

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

在这里插入图片描述
这⾥的每⼀个表，就是真正的⻚表，所以⼀共有 1024 个⻚表。⼀个⻚表⾃⾝占⽤ 4KB ，那么1024 个⻚表⼀共就占⽤了 4MB 的物理内存空间，和之前没差别啊？
从总数上看是这样，但是⼀个应⽤程序是不可能完全使⽤全部的 4GB 空间的，也许只要⼏⼗个⻚表就可以了。例如：⼀个⽤⼾程序的代码段、数据段、栈段，⼀共就需要 10 MB 的空间，那么使⽤ 3 个⻚表就⾜够了。

计算过程：

  • 每⼀个⻚表项指向⼀个 4KB 的物理⻚，那么⼀个⻚表中 1024 > 个⻚表项，⼀共能覆盖 4MB 的物理内存;
  • 那么 10MB 的程序，向上对⻬取整之后(4MB 的倍数，就是 12 MB)，就需要 3 个⻚表就可以了。

1.2.4 ⻚⽬录结构

到⽬前为⽌，每⼀个⻚框都被⼀个⻚表中的⼀个表项来指向了，那么这 1024 个⻚表也需要被管理起来。管理⻚表的表称之为⻚⽬录表，形成⼆级⻚表。如下图所⽰:
在这里插入图片描述

1.2.5 两级⻚表的地址转换

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

  1. 在32位处理器中，采⽤4KB的⻚⼤⼩，则虚拟地址中低12位为⻚偏移，剩下⾼20位给⻚表（物理地址的前20位是页框号后12位为页内偏移），分成两级，每个级别占10个bit（10+10）。
  2. CR3 寄存器 读取⻚⽬录起始地址，再根据⼀级⻚号查⻚⽬录表，找到下⼀级⻚表在物理内存中存放位置。
  3. 根据⼆级⻚号查表（二级页号索引到的页表项里面其实是一个32比特的整数前20位为页框的起始物理基地址后12位就是权限位等，其实页表映射的本质是映射一页（虚拟页）到该页的物理页框的起始物理地址），找到最终想要访问的内存块号。
  4. 结合⻚内偏移量得到物理地址。
  5. 注：⼀个物理⻚的地址⼀定是 4KB 对⻬的(最后的 12 位全部为 0 )，所以其实只需要记录物理⻚地址的⾼ 20 位即可。(也就是说如果知道了物理地址可以把低12位清零再除以4*1024就拿到了页框号有了页框号我们就找到了该page的虚拟地址再加上页内偏移就可以把物理地址反向转化为我们的虚拟地址)
  6. 以上其实就是 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.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 错误中断进程直接挂掉。

1.3 线程的优点

  • 创建⼀个新线程的代价要⽐创建⼀个新进程⼩得多
  • 与进程之间的切换相⽐，线程之间的切换需要操作系统做的⼯作要少很多
  • 最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上下⽂切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。
  • 另外⼀个隐藏的损耗是上下⽂的切换会扰乱处理器的缓存机制。简单的说，**⼀旦去切换上下⽂，处理器中所有已经缓存的内存地址⼀瞬间都作废了。还有⼀个显著的区别是当你改变虚拟内存空间的时候，处理的⻚表缓冲 TLB （快表）会被全部刷新，这将导致内存的访问在⼀段时间内相当的低效。**但是在线程的切换中，不会出现这个问题，当然还有硬件cache。
  • 线程占⽤的资源要⽐进程少很
  • 能充分利⽤多处理器的可并⾏数量
  • 在等待慢速I/O操作结束的同时，程序可执⾏其他的计算任务
  • 计算密集型应⽤，为了能在多处理器系统上运⾏，将计算分解到多个线程中实现
  • I/O密集型应⽤，为了提⾼性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

1.4 线程的缺点

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

1.5 线程异常

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

1.6 线程用途

  • 合理的使⽤多线程，能提⾼CPU密集型程序的执⾏效率
  • 合理的使⽤多线程，能提⾼IO密集型程序的⽤⼾体验（如⽣活中我们⼀边写代码⼀边下载开发⼯具，就是多线程运⾏的⼀种表现

2. Linux进程与线程

2.1 进程和线程

  1. 进程是资源分配的基本单位
  2. 线程是调度的基本单位
  3. 线程共享进程数据，但也拥有⾃⼰的⼀部分数据:
  • 线程ID
  • ⼀组寄存器
  • 栈
  • errno
  • 信号屏蔽字
  • 调度优先级

2.2 进程的多个线程共享

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

⽂件描述符表

  • 每种信号的处理⽅式(SIG_ IGN、SIG_ DFL或者⾃定义的信号处理函数)
  • 当前⼯作⽬录
  • ⽤⼾id和组id

进程和线程的关系如下图:
在这里插入图片描述

2.3 关于进程线程的问题

  • 如何看待之前学习的单进程？具有⼀个线程执⾏流的进程

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

#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 库维持的。(这里可以类比我们的学到的FILE它就是我们c标准库把文件标识符在库内对文件标识符进行了封装，这里我们的线程库对我们的每个线程在线程库里面创建了一个结构体来标记每一个线程)
由于每个进程有⾃⼰独⽴的内存空间，故此“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参数。
#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);
    //被主线程调用函数终止我们的thread3
    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);
}

在这里插入图片描述
在这里插入图片描述

3.5 分离线程

  • 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进⾏pthread_join操作，否则⽆法释放资源，从⽽造成系统泄漏。
  • 如果不关⼼线程的返回值，join是⼀种负担，这个时候，我们可以告诉系统，当线程退出时，⾃动释放线程资源。
int pthread_detach(pthread_t thread);
//可以是线程组内其他线程对⽬标线程进⾏分离，也可以是线程⾃⼰分离:
pthread_detach(pthread_self());

joinable和分离是冲突的，⼀个线程不能既是joinable⼜是分离的。

4. 线程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，本质就是⼀个进程地址空间上的⼀个地址。
在这里插入图片描述
其中线程局部存储是该线程的在tcb有一个指针指向我们的局部存储。

在这里插入图片描述
在这里插入图片描述

5. 线程封装

#pragma once
#include <iostream>
#include <pthread.h>
#include <functional>
#include <cstring>
#include <string.h>
#include<unistd.h>
#include<vector>
namespace  PthreadModlue
{
    using func_t = std::function<void()>; // func_t是一个返回值为void 函数类型
    static int pthreadnum = 0;
    class Pthread
    {

    public:
        Pthread(func_t func) : _isdetach(false), _isrunning(false), res(nullptr), _func(func)
        {
            pthreadnum++;
            _name = "pthread" + std::to_string(pthreadnum);
        }
        ~Pthread() {}
        static void *rountinue(void *args)
        {
            Pthread *ret = static_cast<Pthread *>(args);
            ret->_func();
            ret->_isrunning=false;
            pthread_setname_np(ret->_tid,ret->_name.c_str());
            return ret;
        }
        bool Start()
        {
            if (_isrunning)
                return false;
                _isrunning=true;
            int n = pthread_create(&_tid, nullptr, rountinue, this); // 这里传入this指针
            // 为了方便我们调用类内的我们要执行的函数
            if (n != 0)
            {
                std::cerr << "create thread error: " << strerror(n) << std::endl;
                return false;
            }
            else
            {
                std::cout << _name << " create success" << std::endl;
                return true;
            }
        }
        bool Stop()
        {
            // 停止一个线程要判断他是不是可分离的
            if (_isrunning)
            {
                _isrunning=false;
                int n = pthread_cancel(_tid);
                if (n == 0)
                {
                    std::cout << _name << "stop success!!!" << std::endl;
                    return true;
                }
                else
                {
                    std::cerr << strerror(n) << std::endl;
                }
            }
            return false;
        }
        void Dedath()
        {
            if (_isdetach)
                return;
            if (_isrunning)
            {
                // 运行时我们要进行直接分离
                pthread_detach(_tid);
                EnableDertach();
            }
            // 走到这说明该线程该没运行
            // 此时我们只需要改标志位就好了
            // 之后在join函数判断该标志为就好了
            EnableDertach();
        }
        bool Join()
        {
            if (_isdetach)
            {
                std::cerr << _name<<" " << "alread is detached!!!" << std::endl;
                return false;
            }
            void *ans = nullptr;
            int n = pthread_join(_tid, &ans);
            if (n == 0)
            {
                std::cout << _name <<" "<< "join success!!!" << std::endl;
                return true;
            }
            else 
            {
                std::cout << _name <<" "<< "join failure!!!" << std::endl;
                std::cout<<strerror(n)<<std::endl;
                return false;
            }
        }

    private:
        void EnableDertach()
        {
            std::cout << "pthread is seted joibable!!!" << std::endl;
            _isdetach = true;
        }
        void EnableRunning()
        {
            if (!_isrunning)
                _isrunning = true;
        }

    private:
        pthread_t _tid;    // 线程id
        std::string _name; // 线程名字
        bool _isdetach;    // 是否可分离
        bool _isrunning;   // 是否运行
        void *res;         // 现返回值写入
        func_t _func;      // 现场执行的函数
    };
}
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值