Linux：11.线程概念与控制

线程概念与控制

一.Linux线程概念

进程强调独占，部分共享（比如通信的时候）

线程强调共享部分独占

线程在进程地址空间内运行！

1. 什么是线程

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

概念角度，感性的理解线程

教材：
进程=内核数据结构+代码和数据 (执行流)
线程：是进程内部的一个执行分支(执行流)

内核和资源：
进程：承担分配系统资源的基本实体。
线程：CPU调度的基本单位

结论1：Linux"线程"可以采用进程来模拟
结论2：对资源的划分，本质是对地址空间虚拟地址范围的划分。
虚拟地址，就是资源的代表
结论3：代码区划分？函数就是虚拟地址(逻辑地址)空间的集合！让线程未来执行ELF程序的不同的函数即可！
结论4：以前的进程：内部只有一个线程的进程叫作单进程；
结论5：Linux的线程，就是轻量级进程，或者用轻量级进程模拟实现的！
Linux操作系统视角：进程和线程都是执行流(执行流<=进程);
硬件CPU视角：执行流就是轻量级进程.

2. 分页式存储管理

(1).虚拟地址和页表的由来

思考一下，如果在没有虚拟内存和分页机制的情况下，每一个用户程序在物理内存上所对应的空间必须是连续的，如下图：

因为每一个程序的代码、数据长度都是不一样的，按照这样的映射方式，物理内存将会被分割成各种离散的、大小不同的块。经过一段运行时间之后，有些程序会退出，那么它们占据的物理内存空间可以被回收，导致这些物理内存都是以很多碎片的形式存在。

怎么办呢？**我们希望操作系统提供给用户的空间必须是连续的，但是物理内存最好不要连续。**此时虚拟内存和分页便出现了，如下图所示：

把物理内存按照一个固定的长度的页框进行分割，有时叫做物理页。每个页框包含一个物理页（page）。一个页的大小等于页框的大小。大多数32位体系结构支持4KB 的页，而 64位体系结构一般会支持8KB 的页。区分一页和一个页框是很重要的：

• 页框是一个存储区域；(存储空间)
• 而页是一个数据块，可以存放在任何页框或磁盘中。(内容)

页（Page）
属于逻辑概念（虚拟内存空间里的单位）。
操作系统把虚拟地址空间划分为固定大小的块，每块叫做"页"。
页大小一般是 4KB（x86 默认）。

页框（Page Frame / Frame）
属于物理概念（物理内存里的单位）。
物理内存同样被划分成固定大小的块，称为"页框"或"页帧"。

有了这种机制，CPU 便并非是直接访问物理内存地址，而是通过虚拟地址空间来间接的访问物理内存地址。所谓的虚拟地址空间，是操作系统为每一个正在执行的进程分配的一个逻辑地址，在32位机上，其范围从0 ~ 4G。Linux中逻辑地址就是虚拟地址

操作系统通过将虚拟地址空间和物理内存地址之间建立映射关系，也就是页表，这张表上记录了每一对页和页框的映射关系，能让CPU间接的访问物理内存地址。

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

(2).物理内存管理

假设一个可用的物理内存有 4GB 的空间。按照一个页框的大小 4KB 进行划分， 4GB 的空间就是4GB/4KB = 1048576 个页框。有这么多的物理页，操作系统肯定是要将其管理起来的，操作系统需要知道哪些页正在被使用，哪些页空闲等等。

内核用 struct page 结构表示系统中的每个物理页，出于节省内存的考虑， struct page 中使用了大量的联合体union。

struct page_mem[1048576];所以对物理内存的管理转换成为对数组的操作了；所以，每一个page都会有下标，每一个page的起始物理地址(index*4KB)，就天然知道了；具体物理地址=起始物理地址+页内（4KB)偏移；我们不用在Page里面保存该page的起始地址.

申请进程的载体都是进程/线程！
申请物理内存，是在做什么？
1.查数组，改page;
2.建立内核数据结构的对应关系

/* 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;
                };
            };
        };
        ...
    };
    union {
        /* 内存管理子系统中映射的页表项计数，用于表示页是否已经映射，还用于限制逆向映射
搜索*/
        atomic_t _mapcount;
        unsigned int page_type;
        unsigned int active; /* SLAB */
        int units; /* SLOB */
    };
    ...
        #if defined(WANT_PAGE_VIRTUAL)
        /* 内核虚拟地址（如果没有映射则为NULL，即高端内存） */
        void* virtual;
    #endif /* WANT_PAGE_VIRTUAL */
    ...
}

其中比较重要的几个参数：

1. **flags ：用来存放页的状态。这些状态包括页是不是脏的，是不是被锁定在内存中等。flag的每一位单独表示一种状态，所以它至少可以同时表示出32种不同的状态。这些标志定义在<linux/page-flags.h>中。**其中一些比特位非常重要，如PG_locked用于指定页是否锁定，PG_uptodate用于表示页的数据已经从块设备读取并且没有出现错误。

2. _mapcount ：表示在页表中有多少项指向该页，也就是这一页被引用了多少次。当计数值变为-1时，就说明当前内核并没有引用这一页，于是在新的分配中就可以使用它。

3. **virtual ：是页的虚拟地址。通常情况下，它就是页在虚拟内存中的地址。**有些内存（即所谓的高端内存）并不永久地映射到内核地址空间上。在这种情况下，这个域的值为NULL，需要的时候，必须动态地映射这些页。给反向从物理地址查虚拟地址用。

**要注意的是struct page 与物理页相关，而并非与虚拟页相关。**而系统中的每个物理页都要分配一个这样的结构体，让我们来算算对所有这些页都这么做，到底要消耗掉多少内存。

算struct page 占40个字节的内存吧，假定系统的物理页为4KB 大小，系统有4GB 物理内存。那么系统中共有页面 1048576 个（1兆个），所以描述这么多页面的page结构体消耗的内存只不过40MB ，相对系统4GB 内存而言，仅是很小的一部分罢了。因此，要管理系统中这么多物理页面，这个代价并不算太大。

要知道的是，页的大小对于内存利用和系统开销来说非常重要，页太大，页内必然会剩余较大不能利用的空间（页内碎片）。页太小，虽然可以减小页内碎片的大小，但是页太多，会使得页表太长而占用内存，同时系统频繁地进行页转化，加重系统开销。因此，页的大小应该适中，通常为512B -8KB ，windows/Linux系统的页框大小为4KB。

注意：

• 操作系统也要管理每一个页

(3).页表

**页表中的每一个表项，指向一个物理页的开始地址。**在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 个页表就可以了。

(4).页目录结构

到目前为止，每一个页框都被一个页表中的一个表项来指向了，那么这1024 个页表也需要被管理起来。管理页表的表称之为页目录表，形成二级页表。如下图所示：

• 所有页表的物理地址被页目录表项指向
• 页目录的物理地址被CR3 寄存器指向，这个寄存器中，保存了当前正在执行任务的页目录地址。

所以操作系统在加载用户程序的时候，不仅仅需要为程序内容来分配物理内存，还需要为用来保存程序的页目录和页表分配物理内存。

PT = Page Table = 页表

PTE = Page Table Entry = 页表项

PD = Page Directory = 页目录表

PDE = Page Directory Entry = 页目录表项

PF/PFN = Page Frame (Number) = 页帧 / 页框

Physical Page = 物理页

(5).两级页表的地址转换

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

1. 在32位处理器中，采用4KB的页大小，则虚拟地址中低12位为页偏移，剩下高20位给页表，分成两级，每个级别占10个bit（10+10）。

2. CR3 寄存器读取页目录起始地址，再根据一级页号查页目录表，找到下一级页表在物理内存中存放位置。

3. 根据二级页号查表，找到最终想要访问的内存块号。

4. 结合页内偏移量得到物理地址。

   

5. 注：一个物理页的地址一定是4KB 对齐的(最后的12 位全部为0 )，所以其实只需要记录物理页地址的高 20 位即可。

6. 以上其实就是 MMU 的工作流程。MMU(Memory Manage Unit)是一种硬件电路，其速度很快，主要工作是进行内存管理，地址转换只是它承接的业务之一。

到这里其实还有个问题，MMU要先进行两次页表查询确定物理地址，在确认了权限等问题后，MMU再将这个物理地址发送到总线，内存收到之后开始读取对应地址的数据并返回。那么当页表变为N级时，就变成了N次检索+1次读写。可见，页表级数越多查询的步骤越多，对于CPU来说等待时间越长，效率越低。

让我们现在总结一下：单级页表对连续内存要求高，于是引入了多级页表，但是多级页表也是一把双刃剑，在减少连续存储要求且减少存储空间的同时降低了查询效率。

**有没有提升效率的办法呢？**计算机科学中的所有问题，都可以通过添加一个中间层来解决。MMU 引入了新武器，江湖人称快表的TLB （其实，就是缓存，Translation Lookaside Buffer，学名转译后备缓冲器）

当CPU 给MMU 传新虚拟地址之后， MMU 先去问TLB 那边有没有，如果有就直接拿到物理地址发到总线给内存，齐活。但TLB 容量比较小，难免发生 Cache Miss ，这时候MMU 还有保底的老武器页表，在页表中找到之后MMU 除了把地址发到总线传给内存，还把这条映射关系给到TLB，让它记录一下刷新缓存。

细节1:申请内存->查找数组->找到没有被使用的page->page index->物理页框地址填充进页表;
细节2:写时拷贝，缺页中断，内存申请等等，背后都可能要重新建立新的页表和建立映射关系的操作；
细节3：进程，一张页目录+n张页表构建的映射体系，虚拟地址是索引，物理地址页框是目标，虚拟地址(低12)+页框地址=物理地址;
细节4:为什么是低12位?
答：页框大小是4KB[0，4095]；低位是是因为局部性原理.

执行流看到的资源，本质是：在合法的情况下，你拥有多少虚拟地址，虚拟地址是资源的代表；
虚拟地址空间mm_struct+vm_area_struct本质：进行资源的统计数据和整体数据；
页表是一张虚拟到物理的地图；
资源划分：本质就是地址空间划分；
资源共享：本质就是虚拟地址的共享.

线程的深刻理解
线程进行资源划分：本质是划分地址空间，获得一定范围的合法虚拟地址，在本质，就是在划分页表；
线程进行资源共享：本质是对地址空间的共享，在本质：就是对页表条目的共享.

(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. 页号合法性检查：操作系统在处理中断或异常时，首先检查触发事件的虚拟地址的页号是否合法。如果页号合法但页面不在内存中，则为缺页中断；如果页号非法，则为越界访问。用mm_struct和vm_area_struct检查。
2. 内存映射检查：操作系统还可以检查触发事件的虚拟地址是否在当前进程的内存映射范围内。如果地址在映射范围内但页面不在内存中，则为缺页中断；如果地址不在映射范围内，则为越界访问。

• 线程资源划分的真相：只要将虚拟地址空间进行划分，进程资源就天然被划分好了。

3. 线程的优点

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

4. 线程的缺点

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

5. 线程异常

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

6. 线程用途

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

二.Linux进程VS线程 -- 哪些资源共享，哪些独占

• 进程间具有独立性
• 线程共享地址空间，也就共享进程资源

1. 进程和线程

• 进程是资源分配的基本单位

• 线程是调度的基本单位

• 线程共享进程数据，但也拥有自己的一部分"私有"数据:

• 线程ID

• 一组寄存器，线程的上下文数据, 背后就是线程是被独立调度的！

• 栈, 独立栈结构，线程是一个动态的概念！

• errno

• 信号屏蔽字

• 调度优先级

2. 进程的多个线程共享

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

• 文件描述符表
• 每种信号的处理方式(SIG_ IGN、SIG_ DFL或者自定义的信号处理函数)
• 当前工作目录
• 用户id和组id

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

3. 关于进程线程的问题

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

三.Linux线程控制

Linux系统不存在真正意义上的线程，它所谓的概念，使用轻量级进程模拟的；但OS中，只有轻量级进程；所谓模拟线程，是我们的说法；所以，Linux只会给你提供创建轻量级进程的系统调用！！Linux的线程实现，是在用户层实现的；我们称之为：用户级线程；所以，称pthread为原生线程库

C++11的多线程，在在Linux下，本质是封装了pthread库！

1. POSIX线程库

• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以"pthread_"打头的
• 要使用这些函数库，要通过引入头文 <pthread.h>
• 链接这些线程函数库时要使用编译器命令的"-lpthread"选项

2. 创建线程

(1).pthread_create函数

错误检查:

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

例:

#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);
    }
}

(2).pthread_self函数

打印出来的 tid 是通过 pthread 库中有函数 pthread_self 得到的，它返回一个 pthread_t 类型的变量，指代的是调用 pthread_self 函数的线程的 "ID"。

怎么理解这个"ID"呢？这个"ID"是 pthread 库给每个线程定义的进程内唯一标识，是 pthread 库维持的。

由于每个进程有自己独立的内存空间，故此"ID"的作用域是进程级而非系统级（内核不认识）。不是LWP。

其实 pthread 库也是通过内核提供的系统调用（例如clone）来创建线程的，而内核会为每个线程创建系统全局唯一的"ID"来唯一标识这个线程。

(3).使用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，线程栈，寄存器等属性。CPU调度的时候看lwp，linux中只有轻量级进程.

在 ps -aL 得到的线程ID，有一个线程ID和进程ID相同，这个线程就是主线程，主线程的栈在虚拟地址空间的栈上，而其他线程的栈在是在共享区（堆栈之间），因为pthread系列函数都是pthread库提供给我们的。而pthread库是在共享区的。所以除了主线程之外的其他线程的栈都在共享区。

• 注：

1.关于调度的时间片问题：时间片是将一个进程的时间等分给不同的线程的。
2.任何一个线程崩溃，都会导致整个进程崩溃！

3. 线程终止

如果需要只终止某个线程而不终止整个进程,可以有三种方法:

1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
2. 线程可以调用pthread_ exit终止自己。不能调用exit(),exit()会终止进程.
3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。

• 补充:

1. main函数结束，代表主线程结束，一般也代表进程结束
2. 新线程对应的入口函数，运行结束，代表当前线程运行结束
3. 给线程传递的参数和返回值，可以是任意类型（包括对象）

(1).pthread_exit函数

需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。

(2).pthread_cancel函数

4. 线程等待

• 线程创建好之后，新线程要被主线程等待；否则会有类似僵户进程的问题，造成内存泄漏，

为什么需要线程等待？

• 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
• 创建新的线程不会复用刚才退出线程的地址空间。
• 这里的内存空间指的是线程库里面的空间，如：存储线程相关信息创建的数据结构（TCB)和栈空间等。

(1).pthread_ join函数

调用该函数的线程将挂起等待,直到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参数。

• 技术层面：线程默认是需要被等待的joinable。如果不想让主线程等待新线程，想让新线程结束之后自己退出，可以设置新线程为分离状态(ljoinable/detach)
• 理解层面：线程分离，可以主分离新，也可以新把自己分离。
• 分离的线程，依旧在进程的地址空间中，进程的所有资源，被分离的线程，依旧可以访问，可以操作；只不过主不等待新线程。如果线程被设置为分离状态，不需要进行join，join会失败！

#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);
}

运行结果：
[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

5. 分离线程

• 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
• 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

(1).pthread_detach函数

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离:

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

#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, "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;
}

四.线程ID及进程地址空间布局

• pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的LWP不是一回事。
• 前面讲的LWP属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
• pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
• 线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID：

pthread_t pthread_self(void);

pthread_t 到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。

五.线程封装

1. 普通版本

Thread.hpp

#ifndef _THREAD_H_
#define _THREAD_H_

#include <iostream>
#include <functional>
#include <string>
#include <cstdio>
#include <cstring>
#include <pthread.h>

namespace ThreadModlue
{
    static uint32_t number = 1;//静态常量的无符号32位整型变量(有个小bug)
    class Thread
    {
        using func_t = std::function<void()>; // 暂时这样写就够了
    private:
        void EnableDetach()
        {
            std::cout << "线程被分离了" << std::endl;
            _isdetach = true;
        }
        
        void EnableRunning()
        {
            _isrunning = true;
        }
        
        static void* Routine(void* args)
        {
            Thread *self = static_cast<Thread*>(args);
            self->EnableRunning();
            if(self->_isdetach)
                self->Detach();

            pthread_setname_np(self->_tid,self->_name.c_str());
            self->_func(); // 回调处理
            return nullptr;
        }
    public:
        Thread(func_t func)
            :_tid(0)
            ,_isdetach(false)
            ,_isrunning(false)
            ,res(nullptr)
            ,_func(func)
        {
            _name = "thread-" + std::to_string(number++);
        }
        
        void Detach()
        {
            if(_isdetach)
                return;
            if(_isrunning)
                pthread_detach(_tid);
            EnableDetach();
        }

        bool Start()
        {
            if(_isrunning) return false;
            int n = pthread_create(&_tid, nullptr, Routine, this);
            if(n != 0)
            {
                std::cerr << "create thread error:" << strerror(n) << std::endl;
                return false;
            }
            else
            {
                std::cerr << _name << ":create thread success" << std::endl;
            }
            return true;
        }

        bool Stop()
        {
            if(_isrunning)
            {
                int n = pthread_cancel(_tid);
                if(n != 0)
                {
                    std::cerr << "Stop thread error:" << strerror(n) << std::endl;
                    return false;
                }
                else
                {
                    _isrunning = false;
                    std::cerr << _name << ":Stop success" << std::endl;
                    return true;
                }
            }
            return false;
        }

        void Join()
        {
            if(_isdetach)
            {
                std::cout << "你的线程已经是分离的了,不能进行join" << std::endl;
                return;
            }
            int n = pthread_join(_tid, &res);
            if (n != 0)
            {
                std::cerr << "Join thread error:" << strerror(n) << std::endl;
            }
            else
            {
                std::cerr << _name << ":Join success" << std::endl;
            }
        }

        ~Thread()
        {}
        
    private:
        pthread_t _tid;
        std::string _name;
        bool _isdetach;
        bool _isrunning;
        void *res;
        func_t _func;
    };
}

#endif

Main.cc

#include "Thread.hpp"
#include <unistd.h>

using namespace ThreadModlue;

int main()
{
    Thread t([](){
        while (true)
        {
            char name[128];
            pthread_getname_np(pthread_self(), name, sizeof(name) - 1);
            std::cout << "我是一个新线程" << name << std::endl;
            sleep(1);
        }
        
    });
    
    t.Detach();
    t.Start();
    sleep(5);
    
    t.Stop();
    sleep(5);
    
    t.Join();

    return 0;
}

• pthread_setname_np 和 pthread_getname_np 是两个用于设置和获取线程名称的非标准函数（_np 表示 "non-portable"，即非可移植的）。它们通常在 Linux 和其他一些类 Unix 系统中可用，用于调试和多线程程序的管理; 原理就是线程局部存储，加上了__thread的变量，
• 线程名称长度限制: 在 Linux 上，线程名称的最大长度为 16 个字符（包括结尾的\0 ）。如果名称超过这个长度，会被截断。
• 权限: 通常，只有线程自身可以设置自己的名称。尝试设置其他线程的名称可能会导致错误。

czj@iv-ye46gvrx8gcva4hc07x0:1.thread$ ./thread 
线程被分离了
thread-1:create thread success
我是一个新线程thread-1
我是一个新线程thread-1
我是一个新线程thread-1
我是一个新线程thread-1
我是一个新线程thread-1
thread-1:Stop success

如果要像C++11那样进行可变参数的传递，是可以这样设计的，但是太麻烦了，真到了那一步，就直接用c++11吧，我们的目标主要是理解系统概念对象化，此处不做复杂设计，而且后续可以使用std::bind来进行对象间调用

2. 模板版本

Thread.hpp

#ifndef _THREAD_H_
#define _THREAD_H_

#include <iostream>
#include <functional>
#include <string>
#include <cstdio>
#include <cstring>
#include <pthread.h>

namespace ThreadModlue
{
    static uint32_t number = 1;//静态常量的无符号32位整型变量(有个小bug)
    
    template<class T>
    class Thread
    {
        using func_t = std::function<void(T)>; // 暂时这样写就够了
    private:
        void EnableDetach()
        {
            std::cout << "线程被分离了" << std::endl;
            _isdetach = true;
        }
        
        void EnableRunning()
        {
            _isrunning = true;
        }
        
        static void* Routine(void* args)
        {
            Thread<T> *self = static_cast<Thread<T>*>(args);
            self->EnableRunning();
            if(self->_isdetach)
                self->Detach();
                
            self->_func(self->_data); // 回调处理
            return nullptr;
        }
    public:
        Thread(func_t func, T data)
            :_tid(0)
            ,_isdetach(false)
            ,_isrunning(false)
            ,res(nullptr)
            ,_func(func)
            ,_data(data)
        {
            _name = "thread-" + std::to_string(number++);
        }
        
        void Detach()
        {
            if(_isdetach)
                return;
            if(_isrunning)
                pthread_detach(_tid);
            EnableDetach();
        }

        bool Start()
        {
            if(_isrunning) return false;
            int n = pthread_create(&_tid, nullptr, Routine, this);
            if(n != 0)
            {
                std::cerr << "create thread error:" << strerror(n) << std::endl;
                return false;
            }
            else
            {
                std::cerr << _name << ":create thread success" << std::endl;
            }
            return true;
        }

        bool Stop()
        {
            if(_isrunning)
            {
                int n = pthread_cancel(_tid);
                if(n != 0)
                {
                    std::cerr << "Stop thread error:" << strerror(n) << std::endl;
                    return false;
                }
                else
                {
                    _isrunning = false;
                    std::cerr << _name << ":Stop success" << std::endl;
                    return true;
                }
            }
            return false;
        }

        void Join()
        {
            if(_isdetach)
            {
                std::cout << "你的线程已经是分离的了,不能进行join" << std::endl;
                return;
            }
            int n = pthread_join(_tid, &res);
            if (n != 0)
            {
                std::cerr << "Join thread error:" << strerror(n) << std::endl;
            }
            else
            {
                std::cerr << _name << ":Join success" << std::endl;
            }
        }

        ~Thread()
        {}
        
    private:
        pthread_t _tid;
        std::string _name;
        bool _isdetach;
        bool _isrunning;
        void *res;
        func_t _func;
        T _data;
    };
}

#endif

Main.cc

#include "Thread.hpp"
#include <unistd.h>

using namespace ThreadModlue;

int main()
{
    Thread<int> t([](int n){
        while (true)
        {
            std::cout << "我是一个新线程:" << n << std::endl;
            sleep(1);
        }
        
    },10);
    
    t.Detach();
    t.Start();
    sleep(5);
    
    t.Stop();
    sleep(5);
    
    t.Join();

    return 0;
}

3. 可变参数版本

Thread.hpp

#include <iostream>
#include <functional> // 用于 std::function 和 std::bind
#include <memory>     // 用于 std::shared_ptr 和 std::unique_ptr
#include <pthread.h>  // POSIX 线程库
#include <unistd.h>
class Thread
{
public:
    // 构造函数
    Thread() : thread_id_(0), running_(false) {}
    // 析构函数
    ~Thread()
    {
        if (running_)
        {
            pthread_detach(thread_id_); // 分离线程，避免资源泄漏
        }
    }
    // 启动线程，接受任意可调用对象和参数
    template <typename Callable, typename... Args>
    bool start(Callable &&func, Args &&...args)
    {
        if (running_)
        {
            std::cerr << "Thread is already running!" << std::endl;
            return false;
        }
        // 将可调用对象和参数打包为一个 std::function<void()> 对象
        // 使用 std::bind 将函数和参数绑定在一起
        // std::forward 用于完美转发参数，保持参数的左值/右值属性
        auto task = std::make_shared<std::function<void()>>(
            std::bind(std::forward<Callable>(func), std::forward<Args>(args)...));
        // 将任务传递给线程入口函数
        // 使用 new 在堆上分配 std::shared_ptr，确保任务对象在线程执行期间有效
        if (pthread_create(&thread_id_, nullptr, &Thread::threadEntry, new std::shared_ptr<std::function<void()>>(task)) != 0)
        {
            std::cerr << "Failed to create thread!" << std::endl;
            return false;
        }
        running_ = true;
        return true;
    }
    // 等待线程结束
    void join()
    {
        if (running_)
        {
            pthread_join(thread_id_, nullptr);
            running_ = false;
        }
    }

private:
    pthread_t thread_id_; // 线程 ID
    bool running_;        // 线程是否在运行
    // 线程入口函数
    static void *threadEntry(void *arg)
    {
        // 从参数中提取任务并执行
        // 使用 std::unique_ptr 管理 std::shared_ptr 的指针，确保资源释放
        std::unique_ptr<std::shared_ptr<std::function<void()>>> task_ptr(
            static_cast<std::shared_ptr<std::function<void()>> *>(arg));
        auto task = *task_ptr; // 解引用获取任务对象
        (*task)();             // 执行任务
        return nullptr;
    }
};

Main.cc

#include "Thread.hpp"
#include <unistd.h>

// 示例：测试函数
void printMessage(const std::string &message, int value, int a, int b, int c)
{
    std::cout << "Message: " << message << ", Value: " << value << std::endl;
    std::cout << "a:" << a << std::endl;
    std::cout << "b:" << b << std::endl;
    std::cout << "c:" << c << std::endl;
    sleep(10);
}

int main()
{
    Thread thread;
    // 启动线程，传递任意函数和参数
    // 这里传递了一个普通函数 printMessage 和两个参数 "Hello, World!" 和 42
    thread.start(printMessage, "Hello, World!", 42, 1, 2, 3);
    // 等待线程结束
    thread.join();
    return 0;
}