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

Linux系统编程—线程概念与控制

news 2025/10/28 6:36:01

第一章：Linux线程概念

1-1 什么是线程

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

不过：

仅仅有上面的理解，是不够的
要真正理解线程，就必须搞清楚，内核是如何进行资源划分的，尤其是代码

执行流、线程、task_struct关系

1-2 分页式存储管理

1-2-1 虚拟地址和页表的由来

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

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

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

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

页框是一个存储区域；
而页是一个数据块，可以存放在任何页框或磁盘中。

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

操作系统通过将虚拟地址空间和物理内存地址之间建立映射关系，也就是页表，这张表上记录了每一对页和页框的映射关系，能让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_64BITint pages; /* Nr of pages left */int pobjects; /* Approximate count */
#elseshort 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。

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

1-2-4 页目录结构

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

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

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

1-2-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-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 错误中断进程直接挂掉。

区分页错误类型

如何区分是“非法地址访问”还是“页面缺失”

如何理解虚拟地址空间和进程内存管理的边界

注意：

如何理解我们之前的 new和malloc ？
如何理解我们之前学习的写时拷贝？
申请内存，究竟是在干什么？

如何区分是缺页了，还是真的越界了？

一个问题，越界了一定会报错吗？

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

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

1-3 线程的优点

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

1-4 线程的缺点

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

1-5 线程异常

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

1-6 线程用途

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

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

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

2-1 进程和线程

进程是资源分配的基本单位
线程是调度的基本单位
线程共享进程数据，但也拥有自己的一部分"私有"数据：
- 线程ID
- 一组寄存器，线程的上下文数据
- 栈
- errno
- 信号屏蔽字
- 调度优先级

2-2 进程的多个线程共享

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

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

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

2-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:返回线程IDattr : 设置线程的属性，attr为NULL表⽰使⽤默认属性start_routine : 是个函数地址，线程启动后要执⾏的函数arg : 传给线程启动函数的参数
返回值：成功返回0；失败返回错误码

错误检查：

传统的一些函数是，成功返回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);}
}

#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命令查看线程信息
运行代码后执行：

$ 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库是在共享区的。所以除了主线程之外的其他线程的栈都在共享区。

演示两个线程同时运行

//new thread
void* threadRoutine(void* args) {while (true) {cout << "new thread, pid:" << getpid() << endl;sleep(2);}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, nullptr);//不是系统调用while (true) {cout << "main thread, pid:" << getpid() << endl;sleep(1);}return 0;
}

可以被多个执行流同时执行，show函数被重入了

void show (const string& name) {cout << name << " say# hello thread" << endl;
}
//new thread
void* threadRoutine(void* args) {while (true) {show("[new thread]");sleep(1);}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, nullptr);while (true) {show("[main thread]");sleep(1);}return 0;
}

全局变量在线程中共享

int g_val = 100;
//new thread
void* threadRoutine(void* args) {while (true) {printf("new thread, pid:%d; g_val:%d; &g_val:0x%p\n", getpid(), g_val, &g_val);sleep(1);}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, nullptr);while (true) {printf("main thread, pid:%d; g_val:%d; &g_val:0x%p\n", getpid(), g_val, &g_val);g_val++;sleep(1);}return 0;
}

查看线程ID，是一个很大的数字

void* threadRoutine(void* args) {while (true) {cout << "new thread, pid:" << getpid() << endl;sleep(5);}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, nullptr);while (true) {// printf("main thread, pid:%d; create new thread tid:%ul\n", getpid(), tid);//main thread, pid:10669, create new thread tid:140183830632192 跟LWP不一样printf("main thread, pid:%d; create new thread tid:%p\n", getpid(), tid);//main thread, pid:11300; create new thread tid:0x7fe2803a4700sleep(1);}return 0;
}

回调函数参数

void* threadRoutine(void* args) {const char* name = (const char*)args;while (true) {cout << name << ", pid:" << getpid() << endl;sleep(5);}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void*)"Thread 1");while (true) {printf("main thread, pid:%d; create new thread tid:%p\n", getpid(), tid);sleep(1);}return 0;
}

线程执行函数的参数和返回值

class Request {
public:Request(int start, int end, const string& threadname):start_(start), end_(end), threadname_(threadname){ }
public:int start_;int end_;string threadname_;
};class Response {
public:Response(int result, int exitcode) :result_(result), exitcode_(exitcode) {}
public:int result_;int exitcode_;
};//线程的参数和返回值，不仅仅可以用来传递一般参数，也可以传递对象
void* sumCount(void* args) {Request* rq = static_cast<Request*>(args); //Request* rq = (Request*)args;Response* rsq = new Response(0, 0);for (int i = rq->start_; i <= rq->end_; i++) {cout << rq->threadname_ << " is runing, caling..., " << i << endl;rsq->result_ += i;usleep(25000);}delete rq;return rsq;
}
int main() {pthread_t tid;Request* rq = new Request(1, 100, "Thread 1");pthread_create(&tid, nullptr, sumCount, rq);void* ret;pthread_join(tid, &ret);Response* rsq = static_cast<Response*>(ret);cout << "req->result:" << rsq->result_ << ", exitcode:" << rsq->exitcode_ << endl;delete rsq;return 0;
}

C++11 语言本身已经支持多线程了

//目前，我们的原生线程，pthread库，原生线程库
//C++11 语言本身已经支持多线程了。C++11多线程 vs 原生线程库
void threadrun() {while (true) {cout << "I am a new thread for C++" << endl;sleep(1);}
}
int main() {thread t1(threadrun);//封装原生线程库t1.join();return 0;
}

3-3 线程终止

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

从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit。
线程可以调用pthread_exit终止自己。
一个线程可以调用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；失败返回错误码

任一线程因为异常终止，整个进程都会终止

void* threadRoutine(void* args) {while (true) {cout << "new thread, pid:" << getpid() << endl;sleep(5);int a = 10;a /= 0;}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, nullptr);while (true) {cout << "main thread, pid:" << getpid() << endl;sleep(1);}return 0;
}

线程终止1

void* threadRoutine(void* args) {const char* name = (const char*)args;int cnt = 5;while (true) {cout << name << ", pid:" << getpid() << endl;sleep(1);cnt--;if (cnt == 0) break;}// exit(11);//直接调用exit//exit用来终止进程的，不能用来直接终止线程pthread_exit((void*)100);
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void*)"Thread 1");// return 0;//主线程退出，整个进程就退出//使用exit时，下方没执行void* retval;pthread_join(tid, &retval);//主线程等待的时候，默认是阻塞等待的。cout << "main thread quit..., ret:" << (long long int)retval << endl;return 0;
}

线程终止2 线程取消

void* threadRoutine(void* args) {const char* name = (const char*)args;int cnt = 5;while (true) {cout << name << ", pid:" << getpid() << endl;sleep(1);cnt--;if (cnt == 0) break;}
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void*)"Thread 1");sleep(1);//只是为了保证新线程已启动pthread_cancel(tid);//线程取消（主线程将新线程取消）不常见void* retval;pthread_join(tid, &retval);//主线程等待的时候，默认是阻塞等待的。cout << "main thread quit..., ret:" << (long long int)retval << endl;//线程被取消时退出码是-1(PTHREAD_CANCELED)return 0;
}

3-4 线程等待

为什么需要线程等待？

已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
创建新的线程不会复用刚才退出线程的地址空间。

功能：等待线程结束
原型int pthread_join(pthread_t thread, void** value_ptr);
参数：thread:线程IDvalue_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参数。

主线程和新线程，谁先运行，谁先退
不知道谁先运行，主线程先退，因为它创建的其他线程，它需要管理

void* threadRoutine(void* args) {const char* name = (const char*)args;int cnt = 5;while (true) {cout << name << ", pid:" << getpid() << endl;sleep(1);cnt--;if (cnt == 0) break;}return (void*)1;//走到这里默认线程退出了
}int main() {pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void*)"Thread 1");//线程等待void* retval;pthread_join(tid, &retval);//主线程等待的时候，默认是阻塞等待的。必须等待，防止资源泄露//为什么该函数不考虑异常。因为新线程异常，主线程也挂了，获取不到cout << "main thread quit..., ret:" << (long long int)retval << endl;return 0;
}

3-5 分离线程

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

int pthread_detach(pthread_t thread);

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

pthread_detach(pthread_self());

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和前面说的线程ID不是一回事。
前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_self函数，可以获得线程自身的ID：

pthread_t pthread_self(void);

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

Linux线程概念与执行流管理解析

线程TCB

第五章：线程封装

Thread.hpp

#pragma once#include <iostream>
#include <string>
#include <ctime>
#include <pthread.h>typedef void (*callback_t)();
static int num = 1;class Thread {
public:static void* Routine(void* args) {Thread* thread = static_cast<Thread*>(args);thread->Entry();return nullptr;}
public:Thread(callback_t cb):tid_(0), name_(""), start_timestamp_(0), isrunning_(false), cb_(cb) {}void Run() {name_ = "thread-" + std::to_string(num++);start_timestamp_ = time(nullptr);isrunning_ = true;pthread_create(&tid_, nullptr, Routine, this);}void Join() { pthread_join(tid_, nullptr); isrunning_ = false;}std::string Name() { return name_; }uint64_t StartTimestamp() { return start_timestamp_; }bool IsRunning() { return isrunning_; }void Entry() { cb_(); }~Thread() {}
private:pthread_t tid_;std::string name_;uint64_t start_timestamp_;bool isrunning_;callback_t cb_;
};

Main.cc

#include <iostream>
#include <unistd.h>
#include <vector>
#include "Thread.hpp"using namespace std;
void Print() {while (true) {printf("haha, 我是一个封装的线程...\n");sleep(1);}
}
int main() {vector<Thread> threads;for (int i = 0; i < 10; i++) threads.push_back(Thread(Print));for (auto& t : threads) t.Run();for (auto& t : threads) t.Join();// Thread t(Print);// t.Run();// cout << "是否启动成功: " << t.IsRunning() << endl;// cout << "启动成功时间戳: " << t.StartTimestamp() << endl;// cout << "线程名字: " << t.Name() << endl;// t.Join();return 0;
}

第六章：附录

6-2 线程栈

虽然 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 系统调用：

因此，对于子线程的 stack，它其实是在进程的地址空间中map出来的一块内存区域，原则上是线程私有的，但是同一个进程的所有线程生成的时候，是会浅拷贝生成者的 task_struct 的很多字段，如果愿意，其它线程也还是可以访问到的，一定要注意。

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

创建多线程
验证主线程可以获取其他线程栈上的变量和地址

//创建多线程
#define NUM 3int* p = nullptr;//验证主线程可以获取其他线程栈上的变量和地址struct threadData {string threadname;
};string toHex(pthread_t tid) {char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}void InitThreadData(threadData* td, int number) {td->threadname = "thread-" + to_string(number);
}//所有的线程执行的都是这个函数
void* threadRoutine(void* args) {int test_i = 0;threadData* td = static_cast<threadData*>(args);if (td->threadname == "thread-2") p = &test_i;int i = 0;while (i < NUM) { cout << "pid:" << getgid() << ", tid:" << toHex(pthread_self()) << " threadname:" << td->threadname << ", test_i:" << test_i << ", &test_i:" << toHex((pthread_t)&test_i) << endl;i++, test_i++;sleep(1);}delete td;return nullptr;
}int main() {vector<pthread_t> tids;for (int i = 0; i < NUM; i++) {// 该方式错误，在主线程的栈上开辟的该结构体，下次循环就销毁了// threadData td;// td.threadname = "xxx";pthread_t tid;threadData* td = new threadData;//td是指针变量，把它的值拷贝给threadRoutine中的argsInitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);// sleep(1);}sleep(1);//确保线程2的test_i地址赋值给pcout << "main thread get a thread local value, val:" << *p << ", &val:" << p << endl;for (int i = 0; i < tids.size(); i++) {pthread_join(tids[i], nullptr);}return 0;
}

全局变量是被所有的线程同时看到并访问的

int g_val = 100;struct threadData {string threadname;
};string toHex(pthread_t tid) {char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}void InitThreadData(threadData* td, int number) {td->threadname = "thread-" + to_string(number);
}//所有的线程执行的都是这个函数
void* threadRoutine(void* args) {threadData* td = static_cast<threadData*>(args);int i = 0;while (i < NUM) { cout << "pid:" << getgid() << ", tid:" << toHex(pthread_self()) << " threadname:" << td->threadname << ", g_val:" << g_val << ", &g_val" << &g_val << endl;i++, g_val++;sleep(1);}delete td;return nullptr;
}int main() {vector<pthread_t> tids;for (int i = 0; i < NUM; i++) {pthread_t tid;threadData* td = new threadData;//td是指针变量，把它的值拷贝给threadRoutine中的argsInitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);// sleep(1);}sleep(1);for (int i = 0; i < tids.size(); i++) {pthread_join(tids[i], nullptr);}return 0;
}

如果线程想要一个私有的全局变量

#define NUM 3
// __thread int g_val = 100;//__thread实际应用
__thread unsigned int number = 0;
__thread int pid = 0;struct threadData {string threadname;
};string toHex(pthread_t tid) {char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}void InitThreadData(threadData* td, int number) {td->threadname = "thread-" + to_string(number);
}//所有的线程执行的都是这个函数
void* threadRoutine(void* args) {threadData* td = static_cast<threadData*>(args);//不需要频繁调用系统调用，并且获取的都是自己的数据number = pthread_self();pid = getpid();int i = 0;while (i < NUM) { cout << "number: " << number << ", pid:" << pid << endl;i++;sleep(1);}delete td;return nullptr;
}int main() {vector<pthread_t> tids;for (int i = 0; i < NUM; i++) {pthread_t tid;threadData* td = new threadData;//td是指针变量，把它的值拷贝给threadRoutine中的argsInitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);// sleep(1);}sleep(1);for (int i = 0; i < tids.size(); i++) {pthread_join(tids[i], nullptr);}return 0;
}

作业

1. 关于进程和线程，下列说法正确的是___[多选]

A.线程是资源分配和拥有的单位
B.线程和进程都可并发执行
C.在linux系统中，线程是处理器调度的基本单位
D.线程的粒度小于进程，占用资源更少，因此通常多线程比多进程并发性更高
E.不同的线程共享相同的栈空间

答案：BCD
A 线程是调度的基本单位
E 每个线程在进程虚拟地址空间中会分配拥有相对独立的栈空间，而并不是共享栈空间，这样会导致运行时栈混乱

2. 下面有关线程的说法错误的是？[多选]

A.每个线程有自己独立的地址空间
B.耗时的操作使用线程，提高应用程序响应
C.多CPU系统中，使用线程提高CPU利用率
D.线程包含CPU现场，可以独立执行程序

答案：AD
A错误线程只是在进程虚拟地址空间中拥有相对独立的一块空间，但是本质上说用的是同一个地址空间
B正确使用多线程可以更加充分利用cpu资源，使任务处理效率更高，进而提高程序响应
C正确对于多核心cpu来说，每个核心都有一套独立的寄存器用于进行程序处理，因此可以同时将多个执行流的信息加载到不同核心上并行运行，充分利用cpu资源提高处理效率
D错误线程包含cpu现场，但是线程只是进程中的一个执行流，执行的是程序中的一个片段代码，多个线程完整整体程序的运行

3. 下面关于线程的叙述中，正确的是()。

A.不论是系统支持线程还是用户级线程，其切换都需要内核的支持
B.线程是资源的分配单位，进程是调度和分配的单位
C.不管系统中是否有线程，进程都是拥有资源的独立单位
D.在引入线程的系统中，进程仍是资源分配和调度分派的基本单位

答案：C
A 用户态线程的切换在用户态实现，不需要内核支持
B 进程是资源分配的基本单位，线程是调度的基本单位
D 线程才是调度的基本单位

4. 多线程中栈与堆的基本情况是 ()

A.多个线程共有一个栈，各自有一个堆
B.多个线程共有一个栈, 共有一个堆
C.多个线程各自有一个栈，共有一个堆
D.多个线程各自有一个栈, 各自有一个堆

答案：C
线程独有：栈，寄存器，信号屏蔽字，errno...等信息，因此各个线程各自有各自的栈区，但是堆区共用
因此C选项正确

5. 进程和线程是操作系统中最基本的概念,下列有关描述错误的是 ( )

A.进程是程序的一次执行,而线程可以理解为程序中运行的一个片段
B.由于线程没有独立的地址空间,同一个进程的一组线程可以共享访问大部分该进程资源,这些线程之间的通信很高效
C.线程之间的通信简单(共享了虚拟地址空间及页表，因此函数传参以及全局变量即可实现通信),而不同进程之间的通信更为复杂,通常需要调用内核实现
D.线程有独立的虚拟地址空间,但是拥有的资源相对进程来说,只有运行所必须的栈,寄存器等

答案：D
D错误线程并没有独立的虚拟地址空间，只是在进程虚拟地址空间中拥有相对独立的一块空间

6. 关于多线程和多进程编程，下面描述正确的是（） [多选]

A.多进程里，子进程可复制父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，但拥有自己的栈空间
B.线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护
C.线程的通信速度更快，切换更快，因为他们在同一地址空间内，且还共享了很多其他的进程资源，比如页表指针这些是不需要切换的
D.线程使用公共变量/内存时需要使用同步机制，因为他们在同一地址空间内
E.因多进程里，每个子进程有自己的地址空间，因此相互之间通信时，线程不如进程灵活和方便

答案：ACD
B 线程拥有自己的栈空间且共享数据没错，但是资源消耗更小，且便于进程内线程间的资源管理和保护，否则会造成栈混乱
E 进程因为每个都有独立的虚拟地址空间，因此通信麻烦，需要调用内核接口实现。而线程间共用同一个虚拟地址空间，通过全局变量以及传参就可实现通信，因此更加灵活方便

7. 有关进程和线程的说法，错误的是（）[多选]

A.一个程序至少有一个进程，一个进程至少有一个线程
B.操作系统的最小调度单位是进程
C.线程自己不拥有系统资源
D.一个线程可以创建和撤销另一个线程

答案：AB
A错误程序是静态的，不涉及进程，进程是程序运行时的实体，是一次程序的运行
B错误操作系统的最小调度单位是线程
C正确进程是资源的分配单位，所以线程并不拥有系统资源，而是共享使用进程的资源，进程的资源由系统进行分配
D正确任何一个线程都可以创建或撤销另一个线程

8. 关于多线程和多线程编程，以下哪些说法正确的（）[多选]

A.多进程之间的数据共享比多线程编程复杂
B.多线程的创建，切换，销毁速度快于多进程
C.对于大量的计算优先使用多进程
D.多线程没有内存隔离，单个线程崩溃会导致整个应用程序的退出

答案：ABD
A正确因为线程之间共享地址空间，因此通信更加方便，全局数据以及函数传参都可以实现，而进程间则需要系统调用来完成
B正确因为线程之间共享了进程中的大部分资源，因此共享的数据不需要重新创建或销毁，因此消耗上低于进程，反之也就是速度快于进程
C错误大量的计算使用多进程和多线程都可以实现并行 / 并发处理，而线程的资源消耗小于多进程，而稳定向较多进程有所不如，因此还要看具体更加细致的需求场景
D正确其实不仅仅是内存隔离的问题，还有就是异常针对的是整个进程，因此单个线程的崩溃会导致异常针对进程触发，最终退出整个进程。

9. 进程和线程是操作系统中最基本的概念,下列有关描述错误的是（）

A.进程是程序的一次执行,而线程可以理解为程序中运行的一个片段
B.由于线程没有独立的地址空间,因此同一个进程的一组线程可以共享访问该进程大部分资源, 这些线程之间的通信也很高效
C.线程之间的通信简单(共享地址空间和页表信息，因此传参以及全局数据都可以实现通信),而不同进程之间的通信更为复杂,通常需要调用内核实现
D.线程有独立的虚拟地址空间,但是拥有的资源相对进程来说,只有运行所必须的栈, 寄存器等

答案：D
D 线程并没有独立的虚拟地址空间，只是在进程虚拟地址空间中拥有相对独立的一块空间

10. 下述有关Linux进程和线程的描述，正确的有？[多选]

A.在linux 中，进程比线程安全的原因是进程之间不会共享数据
B.进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）
C.进程——资源分配的最小单位，线程——程序执行的最小单位
D.进程和线程都有单独的地址空间

答案：BC
A错误进程比线程安全的原因是每个进程有独立的虚拟地址空间，有自己独有的数据，具有独立性，不会数据共享这个太过宽泛与片面
D错误进程有独立的地址空间，但是同一个进程的线程之间共享同一个地址空间

11. 简述轻量级进程ID与进程ID之间的区别

因为Linux下的轻量级进程是一个pcb，每个轻量级进程都有一个自己的轻量级进程ID（pcb中的pid），而同一个程序中的轻量级进程组成线程组，拥有一个共同的线程组ID

12. 请简述LWP与pthread_create创建的线程之间的关系

pthread_create是一个库函数，功能是在用户态创建一个用户线程，而这个线程的运行调度是基于一个轻量级进程实现的。

13. 请简述什么是LWP

LWP是轻量级进程，在Linux下进程是资源分配的基本单位，线程是cpu调度的基本单位，而线程使用进程pcb描述实现，并且同一个进程中的所有pcb共用同一个虚拟地址空间，因此相较于传统进程更加的轻量化

14. 以下描述正确的有：[多选]

A.pthread_create函数是一个库函数，代码当中如果使用该函数创建线程，则需要在编译的时候链接“libpthread.so”线程库
B.那个线程调用pthread_exit函数，那个线程就退出。俗称“谁调用谁退出”
C.在有多个线程的情况下，主线程调用pthread_cancel(pthread_self()), 则主线程状态为Z，其他线程正常运行
D.在有多个线程的情况下，主线程从main函数的return返回或者调用pthread_exit函数，则整个进程退出

答案：ABC
C：主线程调用pthread_cancel(pthread_self())函数来退出自己，则主线程对应的轻量级进程状态变更成为Z，其他线程不受影响，这是正确的（正常情况下我们也不会这么做....）
D：主线程调用pthread_exit只是退出主线程，并不会导致进程的退出

15. 以下描述正确的有：

A.可以使用ps -l命令查看轻量级进程信息
B.可以使用ps -L命令查看轻量级进程信息
C.可以使用pthread_self接口获取轻量级进程ID
D.可以使用getpid接口接口获取轻量级进程ID

答案：B
A错误，B正确 ps命令用于查看进程信息，其中 - L选项用于查看轻量级进程信息
C错误 pthread_self() 用于获取用户态线程的tid，而并非轻量级进程ID
D错误 getpid() 用于获取当前进程的id, 而并非某个特定轻量级进程

16. 请简述什么是线程互斥，为什么需要互斥

线程互斥指的是在多个线程间对临界资源进行争抢访问时有可能会造成数据二义，因此通过保证同一时间只有一个线程能够访问临界资源的方式实现线程对临界资源的访问安全性

17. 设两个进程共用一个临界资源的互斥信号量mutex，当mutex＝1时表示（）。

A.一个进程进入了临界区，另一个进程等待
B.没有一个进程进入临界区
C.两个进程都进入临界区
D.两个进程都在等待

答案：B
mutex简单理解就是一个0 / 1的计数器，用于标记资源访问状态：

0表示已经有执行流加锁成功，资源处于不可访问，
1表示未加锁，资源可访问。

因此选择B选项，表示没有执行流完成加锁对资源进行访问，资源处于可访问状态。

18. 进程A、B共享变量x，需要互斥执行；进程B、C共享变量y，B、C也需要互斥执行，因此进程A、C必须互斥执行

A.错
B.对

答案：A
进程A操作的x，C并不进行操作；进程C操作的y，进程A并不操作；因此A和C并不需要互斥执行

19. 在一段时间内，只允许一个进程访问的资源被称为（）

A.共享资源
B.临界区
C.临界资源
D.共享区

答案：C
A 共享资源表示能够被多个执行流同时访问的资源
B 对临界资源进行操作的代码段被称作临界区
C 临界资源表示同一时间只能有一个执行流访问的共享资源
D 没有这个专业说法，非要简单理解就是可以共同执行的代码片段
题目为选择同一时间只有一个进程能访问的资源，则就是临界资源，因此选择C选项

20. 下列不属于POSIX互斥锁相关函数的是：（）

A.int pthread_mutex_destroy(pthread_mutex_t* mutex)
B.int pthread_mutex_lock(pthread_mutex_t* mutex)
C.int pthread_mutex_trylock(pthread_mutex_t* mutex)
D.int pthread_mutex_create(pthread_mutex_t* mutex)

答案：D
A pthread_mutex_destroy 用于销毁互斥锁
B pthread_mutex_lock 用于加锁保护临界区
C pthread_mutex_trylock 用户非阻塞加锁
D 没有这个函数 pthread_create是线程创建函数，而互斥锁并没有对应的创建函数，而是直接定义pthread_mutex_t类型的互斥锁变量

查看全文

http://www.dtcms.com/a/535696.html