当前位置：首页 > news >正文

Linux之线程概念与控制

news 来源：原创 2025/6/19 5:26:19

一、Linux线程概念

1.1、什么是线程

在⼀个程序⾥的⼀个执⾏路线就叫做线程（thread）。更准确的定义是：线程是“⼀个进程内部的控制序列”。
⼀切进程⾄少都有⼀个执⾏线程。
线程在进程内部运⾏，本质是在进程地址空间内运⾏。
在Linux系统中，在CPU眼中，看到的PCB都要⽐传统的进程更加轻量化。
透过进程虚拟地址空间，可以看到进程的⼤部分资源，将进程资源合理分配给每个执⾏流，就形成了线程执⾏流。
Linux下的线程，是用进程模拟实现的。如下图，每个task_struct都代表一个线程，而所有的task_struct + mm_struct + 页表这个整体才是进程。

1.2、分⻚式存储管理

1.2.1、虚拟地址和⻚表的由来

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

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

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

把物理内存按照⼀个固定的⻓度的⻚框进⾏分割，有时叫做页帧。每个⻚框包含⼀个物理⻚（page）。⼀个⻚的⼤⼩等于⻚框的⼤⼩。⼤多数32位体系结构⽀持 4KB 的⻚，⽽64位体系结构⼀般会⽀持 8KB 的⻚。区分⼀⻚和⼀个⻚框是很重要的：

⻚框是⼀个存储区域；
⽽⻚是⼀个数据块，可以存放在任何⻚框或磁盘中。

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

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

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

1.2.2、物理内存管理

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

内核⽤ 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;

};

    };

};

        ...

    };

        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 */

        ...

}

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

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

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

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

要知道的是，⻚的⼤⼩对于内存利⽤和系统开销来说⾮常重要，⻚太⼤，⻚必然会剩余较⼤不能利⽤的空间（⻚内碎⽚）。⻚太⼩，虽然可以减⼩⻚内碎⽚的⼤⼩，但是⻚太多，会使得⻚表太⻓⽽占⽤内存，同时系统频繁地进⾏⻚转化，加重系统开销。因此，⻚的⼤⼩应该适中，通常为 512B - 8KB ，windows系统的⻚框⼤⼩为4KB。

1.2.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的倍数，就是12MB)，就需要3个⻚表就可以了。

1.2.4、⻚⽬录结构

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

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

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

1.2.5、两级⻚表的地址转换

下⾯以⼀个逻辑地址为例。将逻辑地址（ 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.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、线程的缺点

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

1.5、线程异常

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

1.6、线程用途

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

二、Linux进程VS线程

2.1、进程和线程

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

注意：理论上，堆空间是共享的！谁拿着堆空间的入口地址，谁就能访问该堆区！每个线程的栈是独立的，但并不代表其它线程无法访问，和堆一样，只要拿到这块栈空间的地址，就可以访问。

示例代码：（代码中的接口下面有介绍）

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>int *addr = nullptr;void *start1(void *args)
{std::string name = static_cast<const char *>(args);int a = 100;addr = &a;while(true){std::cout << name << " local val a: " << a <<std::endl;sleep(1);}
}void *start2(void *args)
{std::string name = static_cast<const char *>(args);while(true){if(addr != nullptr)std::cout << name << " local val a: " << (*addr)++ <<std::endl;sleep(1);}
}int main()
{pthread_t tid1,tid2;pthread_create(&tid1, nullptr, start1, (void*)"thread-1");pthread_create(&tid2, nullptr, start2, (void*)"thread-2");pthread_join(tid1,nullptr);pthread_join(tid2,nullptr);return 0;
}

效果：

从上面运行结果可以看出，当第二个线程拿到第一个线程中的变量在栈上的地址后，是可以访问和修改这块空间中的内容的，而且第一个线程也会受到修改的影响。

2.2、进程的多个线程共享

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

⽂件描述符表
每种信号的处理⽅式(SIG_ GN、SIG_DFL或者⾃定义的信号处理函数)
当前⼯作⽬录
⽤⼾ id 和组 id

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

如何看待单进程？答：具有⼀个线程执⾏流的进程

三、Linux线程控制

3.1、POSIX线程库

与线程有关的函数构成了⼀个完整的系列，绝⼤多数函数的名字都是以“pthread_”打头的。
要使⽤这些函数库，要通过引⼊头⽂件<pthread.h>。
链接这些线程函数库时要使⽤编译器命令的“-lpthread”选项，因为这些函数不是系统调用，而是 glibc 给我们封装好的库。

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

错误检查：

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

示例代码一：

#include <iostream>
#include <unistd.h>
#include <pthread.h>//新线程
void *run(void *args)
{   while(true){std::cout << "new thread, pid: " << getpid() <<std::endl;sleep(1);}return nullptr;
}int main()
{std::cout << "我是一个进程" << getpid() << std::endl;pthread_t tid;pthread_create(&tid, nullptr, run, (void*)"thread-1");//主线程while(true){std::cout << "main thread, pid: " << getpid() <<std::endl;sleep(1);}return 0;
}

效果：

上面代码中的的tid是通过pthread库中有函数pthread_self 得到的，它返回⼀个pthread_t类型的变量，指代的是调⽤pthread_self函数的线程的“ID”。

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

由于每个进程有⾃⼰独⽴的内存空间，故此“ID”的作⽤域是进程级⽽⾮系统级（内核不认识）。其实pthread库也是通过内核提供的系统调⽤（例如clone）来创建线程的，⽽内核会为每个线程创建系统全局唯⼀的“ID”来唯⼀标识这个线程。

使⽤PS命令查看线程信息：（运⾏代码后执⾏）

-L 选项：打印线程信息

LWP是什么呢？LWP得到的是真正的线程ID。之前使⽤pthread_self 得到的这个数实际上是⼀个地址，在虚拟地址空间上的⼀个地址，通过这个地址，可以找到关于这个线程的基本信息，包括线程ID，线程栈，寄存器等属性。

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

注意：

线程创建出来，要对进程的时间片进行瓜分。
新线程之间以及新线程和main线程谁先运行，不能确定。
当多个线程执行同一个方法时，该方法就是被重入了。
默认情况下，对于同一进程下的不同线程而言，显示器文件是共享资源，不加保护的情况下写入数据，会造成数据不一致问题（即打印的数据错乱）。

示例代码二：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>int gval = 100;std::string toHex(pthread_t tid)
{char buffer[64];snprintf(buffer, sizeof(buffer), "0x%lx", tid);return buffer;
}//多个线程都执行该方法时，该方法被重入了
void *runtine1(void *args)
{std::string name = static_cast<const char *>(args);while(true){std::cout << "我是新线程，我的名字是：" << name << ", my tid is: " << toHex(pthread_self()) << "全局变量（修改）" << gval << std::endl;gval++;sleep(1);}return 0;
}void *runtine2(void *args)
{std::string name = static_cast<const char *>(args);while(true){std::cout << "我是新线程，我的名字是：" << name << ", my tid is: " << toHex(pthread_self()) << "全局变量（只读）" << gval  << std::endl;sleep(1);}return 0;
}int main()
{//新线程和main线程谁先运行，不确定pthread_t tid1;pthread_create(&tid1, nullptr, runtine1, (void*)"thread-1");pthread_t tid2;pthread_create(&tid2, nullptr, runtine2, (void*)"thread-2");printf("new thread id: 0x%lx\n", tid1);printf("new thread id: 0x%lx\n", tid2);while(true){std::cout << "我是main线程" << std::endl;sleep(1);}return 0;
}

效果：

结论：全局变量在线程内部是共享的。

示例代码三：（传参问题）

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>class ThreadData
{
public:ThreadData(const std::string &name, int a, int b){_name = name;_a = a;_b = b;}std::string Name(){ return _name; }int A(){return _a;}int B(){return _b;}~ThreadData(){}
private:std::string _name;int _a;int _b;
};void *routine1(void *args)
{ThreadData* td = static_cast<ThreadData*>(args);//通过指针访问数据，并使用数据进行操作return 0;
}int main()
{//传参问题pthread_t tid1;ThreadData *td = new ThreadData("thread-1", 10, 20);pthread_create(&tid1, nullptr, routine1, td);//...return 0;
}

结论：我们可以传递任意类型的参数，如果想携带多个数据，可以封装为类或者结构体。

3.3、线程终止

如果需要只终⽌某个线程⽽不终⽌整个进程,可以有三种⽅法：

从线程函数return。这种⽅法对主线程不适⽤，从main函数return相当于调⽤exit。
线程可以调⽤pthread_exit终⽌⾃⼰。
⼀个线程可以调⽤pthread_cancel终⽌同⼀进程中的另⼀个线程。

注意：

调用 exit 也可以终止线程，但是 exit 不仅会终止当前线程，它还会终止整个进程，这样当前进程内的所有线程也就都终止了。
取消线程，一定是目标线程已经启动了。

pthread_exit函数：

功能：线程终⽌

原型:

        void pthread_exit(void *value_ptr);

参数:

         value_ptr：value_ptr不要指向⼀个局部变量。

返回值：

        ⽆返回值，跟进程⼀样，线程结束的时候⽆法返回到它的调⽤者（⾃⾝）

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

示例代码：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>
#include <pthread.h>void *start(void *args)
{sleep(2);pthread_exit((void *)10);
}int main()
{pthread_t tid;pthread_create(&tid, nullptr, start, (void *)"thread-1");void *ret = nullptr;pthread_join(tid, &ret);std::cout << "new thread exit code: " << (long long)ret << std::endl;return 0;
}

效果：

pthread_cancel函数：

功能：取消⼀个执⾏中的线程

原型:

        int pthread_cancel(pthread_t thread);

参数:

         thread：线程ID

返回值：

        成功返回0；失败返回错误码

示例代码：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>
#include <pthread.h>void *start(void *args)
{while(true){std::cout << "new thread" << std::endl;sleep(1);}return 0;
}int main()
{pthread_t tid;pthread_create(&tid, nullptr, start, (void *)"thread-1");sleep(3);pthread_cancel(tid);std::cout << "取消线程" << tid << std::endl;sleep(3);void *ret = nullptr;pthread_join(tid, &ret);std::cout << "new thread exit code: " << (long long)ret << std::endl;return 0;
}

效果：

3.4、线程等待

为什么需要线程等待？

已经退出的线程，其空间没有被释放，仍然在进程的地址空间内，类似于僵尸进程问题。
创建新的线程不会复⽤刚才退出线程的地址空间。
为了知道新线程的执行结果。

功能：等待线程结束

原型

        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参数。

示例代码：（等待并获得返回值）

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>std::string toHex(pthread_t tid)
{char buffer[64];snprintf(buffer, sizeof(buffer), "0x%lx", tid);return buffer;
}void *routine1(void *args)
{std::string name = static_cast<const char *>(args);while(true){std::cout << "我是新线程，我的名字是：" << name << ", my tid is: " << toHex(pthread_self()) << std::endl;sleep(1);break;}return (void*)10;
}int main()
{pthread_t tid1;pthread_create(&tid1, nullptr, routine1, (void*)"thread-1");//阻塞式等待void *ret = nullptr;int n = pthread_join(tid1, &ret);if(n != 0){std::cerr << "join error: " << n << ", " << strerror(n) << std::endl;return 1;}std::cout << "join success ret: " << (long long)ret << std::endl;return 0;
}

效果：

3.5、分离线程

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

int pthread_detach(pthread_t thread);

可以是线程组内其他线程对⽬标线程进⾏分离，也可以是线程⾃⼰分离：

pthread_detach(pthread_self());

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

注意：我们不可以直接通过 exec 系列接口来换某个线程的代码和数据，因为 exec 系列接口是更换整个进程的信息，一个进程的信息是该进程中所有线程共享的，也就是说每个线程的资源都来自进程，如果一个线程使用 exec 系列接口替换进程信息后，其他线程可能就会无法正常运行，但是如果我们需要进行程序替换，可以在目标线程中创建子进程，然后使用 exec 系列接口替换子进程的代码和数据。

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

pthread_create函数会产⽣⼀个线程ID，存放在第⼀个参数指向的地址中。该线程ID和前⾯说的线程ID不是⼀回事。
前⾯讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最⼩单位，所以需要⼀个数值来唯⼀表⽰该线程——LWP。
pthread_create函数第⼀个参数指向⼀个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_self函数，可以获得线程⾃⾝的ID：

pthread_t pthread_self(void);

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

结论：从上面图中，我们可以得到结论，进程的栈是主线程占用的，而新创建的线程的栈是在共享区上动态创建的，即每创建一个线程就在共享区申请一块空间作为该线程的栈。

线程局部存储：正常情况下，我们创建一个全局变量，那么这个全局变量是所有线程所共享的，每个线程都可以访问它，也都可以修改它，其他线程也会看到修改后的值，但是如果我们定义全局变量时在前面加上 __thread，每个线程就会独立有一份该变量，一个线程修改，另一个线程中该变量不会受到影响。

__thread int num = 0; //全局变量 //线程的局部存储

五、线程封装

Makefile:

bin=testThread
cc=g++
src=$(wildcard *.cc)
obj=$(src:.cc=.o)$(bin):$(obj)$(cc) -o $@ $^ -lpthread
%.o:%.cc$(cc) -c $< -std=c++17.PHONY:clean
clean:rm -f $(bin) $(obj).PHONY:test
test:echo $(src)echo $(obj)

Thread.hpp

#ifndef _THREAD_HPP__
#define _THREAD_HPP__#include <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <sys/types.h>
#include <unistd.h>namespace ThreadModule
{static int number = -1;enum class TSTATUS{NEW,RUNNING,STOP};template<typename T>class Thread{using func_t = std::function<void(T)>;private://该方法必须设计为静态方法，//因为调用pthread_creat时传入的方法形参必须是void* //但是类的成员方法第一个形参是this指针static void *Routine(void *args){Thread<T> *t = static_cast<Thread<T> *>(args);t->_status = TSTATUS::RUNNING;t->_func(t->_data);return nullptr;}void EnableDetach(){ _joinable = false};public:Thread(func_t func, T data):_func(func),_data(data),_status(TSTATUS::NEW),_joinable(false){_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 = phtread_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; //当前状态 新建  运行  停止T _data; //线程执行方法的参数};  
}// v1
// namespace ThreadModule
// {
//     using func_t = std::function<void()>;
//     static int number = 1;
//     enum class TSTATUS
//     {
//         NEW,
//         RUNNING,
//         STOP
//     };//     class Thread
//     {
//     private:
//         // 成员方法！
//         static void *Routine(void *args)
//         {
//             Thread *t = static_cast<Thread *>(args);
//             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); // TODO
//                 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

Main.cc:

#include "Thread.hpp"
#include <unordered_map>
#include <memory>#define NUM 10// using thread_ptr_t = std::shared_ptr<ThreadModule::Thread>;class threadData
{
public:int max;int start;
};void Count(threadData td)
{for (int i = td.start; i < td.max; i++){std::cout << "i == " << i << std::endl;sleep(1);}
}int main()
{threadData td;td.max = 60;td.start = 50;ThreadModule::Thread<threadData> t(Count, td);// ThreadModule::Thread<int> t(Count, 10);t.Start();t.Join();// 先描述，在组织！// 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();// }// ThreadModule::Thread t([](){//     while(true)//     {//         std::cout << "hello world" << std::endl;//         sleep(1);//     }// });// t.Start();// std::cout << t.Name() << "is running" << std::endl;// sleep(5);// t.Stop();// std::cout << "Stop thread : " << t.Name()<< std::endl;// sleep(1);// t.Join();// std::cout << "Join thread : " << t.Name()<< std::endl;return 0;
}

六、线程栈

虽然 Linux 将线程和进程不加区分的统⼀到了task_struct ，但是对待其地址空间的 stack 还是有些区别的。

对于 Linux 进程或者说主线程，简单理解就是main函数的栈空间，在fork的时候，实际上就是复制了⽗亲的 stack 空间地址，然后写时拷⻉(cow)以及动态增⻓。如果扩充超出该上限则栈溢出会报段错误（发送段错误信号给该进程）。进程栈是唯⼀可以访问未映射⻚⽽不⼀定会发⽣段错误⸺超出扩充上限才报。
然⽽对于主线程⽣成的⼦线程⽽⾔，其 stack 将不再是向下⽣⻓的，⽽是事先固定下来的。线程栈⼀般是调⽤glibc/uclibc等的 pthread 库接⼝ pthread_create 创建的线程，在⽂件映射区（或称之为共享区）。其中使⽤ mmap 系统调⽤，这个可以从 glibc 的nptl/allocatestack.c 中的 allocate_stack 函数中看到：

mem = mmap (NULL, size, prot, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);

此调⽤中的 size 参数的获取很是复杂，你可以⼿⼯传⼊stack的⼤⼩，也可以使⽤默认的，⼀般⽽⾔就是默认的 8M 。这些都不重要，重要的是，这种stack不能动态增⻓，⼀旦⽤尽就没了，这是和⽣成进程的fork不同的地⽅。在glibc中通过mmap得到了stack之后，底层将调⽤ sys_clone 系统调⽤：

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

}