【Linux跬步积累】—— 线程

🌏博客主页：PH_modest的博客主页
🚩当前专栏：Linux跬步积累
💌其他专栏：
🔴 每日一题
🟡 C++跬步积累
🟢 C语言跬步积累
🌈座右铭：广积粮，缓称王！

---

Linux线程概念

什么是线程

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

需要明确的是，一个进程的创建实际上伴随着其进程控制块（task_struct）、进程地址空间（mm_struct）以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。

每个进程都有自己独立的进程地址空间和独立的页表，这也就意味着所有进程在运行时本身就具有独立性。

但如果我们在创建“进程”时，只创建task_struct，并要求创建出来的task_struct和父task_struct共享进程地址空间和页表，那么创建的结果就是下面这样的：

此时其实我们创建的就是四个线程：

• 其中每个线程都是当前进程的一个执行流，也就是我们常说的“线程是进程内部的一个执行分支”。
• 同时我们可以看出，线程在进程内部运行，也就是说，进程申请的所有资源，几乎都是被所有线程共享的。

注意： 单纯从技术角度，这个是一定能实现的，因它比创建一个原始进程所做的工作更加轻量化。

该如何重新理解之前的进程？

下面蓝色方框内的，我们称为进程：

因此，所谓的进程并不是通过task_struct来衡量的，除了task_struct之外，一个进程还要有进程地址空间、文件、信号等等，合起来称之为一个进程。

现在我们应该站在内核角度来理解进程：承担分配系统资源的基本实体，叫做进程。

换言之，当我们创建进程时，就是创建一个task_struct、创建进程地址空间、维护页表，然后在物理地址内开辟空间、构建映射，打开进程默认打开的相关文件、注册信号对应的处理方案等。

而我们之前接触到的进程都只有一个task_struct，也就是该进程内部只有一个执行流，即单执行流进程，反之，内部有多个执行流的进程叫做多执行流进程。

在Linux中，站在CPU的角度，能否识别当前调度的task_struct是进程还是线程？

答案是不能，也不需要，因为CPU只关心一个一个的独立执行流。无论进程内部是有一个执行流还是多个执行流，CPU都是以task_struct为单位调度的。

单执行流进程被调度：

多执行流进程被调度：

因此，CPU看到的虽然还是task_struct，但已经比传统的进程要更加轻量化了。

LInux下并不存在真正的多线程！而是用进程模拟的！

操作系统中存在大量进程，一个进程又有一个或多个线程，因此线程的数量一定比进程的数量多，当线程的数量足够多的时候，很明显线程的执行粒度要比进程更细。

如果一款操作系统要支持真的线程，那么就需要对这些线程进行管理，比如说，创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等，所有的这一套比较进程都需要另起炉灶，搭建一套与之平行的线程管理模块。

因此，如果要支持真的线程，一定会提高设计操作系统的复杂度。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。

但也有支持线程的操作系统，比如Windows操作系统，因此Windows操作系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂的多。

既然在Linux没有真正意义的线程，那么也就绝对没有真正意义上的线程相关的系统调用！

这就很好理解了，既然在Linux中都没有真正意义上的线程，那么自然也就没有真正意义上的线程相关的系统调用了。但是Linux可以提供创建轻量级进程的接口，也就是创建进程，共享空间，其中最典型的代表就是vfork函数。

vfork函数的功能就是创建子进程，但是父子共享空间，vfork的函数原型如下：

pid_t vfork(void);

vfork函数的返回值与fork函数的返回值相同：

• 给父进程返回子进程的PID。
• 给子进程返回0。

只不过vfork创建出来的子进程与父进程共享地址空间，例如下面的代码，子进程将全局变量g_val由100改成了200，父进程休眠3秒后再读取全局变量的值，观察一下输出的结果。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int g_val = 100;
int main()
{pid_t id = vfork();if (id == 0){//childg_val = 200;printf("child:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);exit(0);}//fathersleep(3);printf("father:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);return 0;
}

可以看到，父进程读取到g_val的值是子进程修改后的值，也就证明了vfork创建的子进程与其父进程是共享地址空间。

原生线程库pthread

在Linux中，站在内核角度没有真正意义上线程相关的接口，但是站在用户角度，当用户想创建一个线程时更希望使用thread_create这样类似的接口，而不是vfork函数，因此系统为用户层提供了原生线程库pthread。

原生线程库实际上就是对轻量级进程系统调用的封装，在用户层面模拟实现了一套线程相关的接口。

因此对于我们来讲，在LInux下学习线程实际上就是学习在用户层模拟实现这一套接口，而并非操作系统的接口。

二级页表

以32位平台为例，在32位平台下一个有2³²个地址，也就意味着有2³²个地址需要被映射。

如果页表只是单纯的一张表，那么它就需要存储2³²个虚拟地址和物理地址的映射关系：

每一个页表除了有虚拟地址和物理地址之间的映射外，还需要一些和权限有关的信息，比如我们所说的用户级页表和内核级页表，实际就是通过权限进行区分的。

但如果只有页表只有一张表，需要存储的空间过于大，内存无法存储这样的页表。

因此我们所说的页表并不是一张表。

在二级页表结构中，页表被分为两个层次：

• 外层页表（Page Directory）：这个层级的页表包含指向内层页表的指针。每个条目（通常称为页目录项）指向一个内层页表。

• 内层页表（Page Table）：这个层级的页表包含实际的页表项，这些页表项将虚拟页号映射到物理页号。

当进行地址转换时，处理器首先使用虚拟地址中的高位索引外层页表，找到对应的内层页表的地址。然后，处理器使用虚拟地址中的中间位索引这个内层页表，找到对应的页表项，该页表项包含了物理页号。最后，处理器使用虚拟地址中的低位来确定页内偏移量，将物理页号和页内偏移量组合起来形成完整的物理地址。

注意： 在Linux中，32位平台下用的是二级页表，而64位平台下用的是多级页表。

修改常量字符串为什么会触发段错误？

当我们要修改一个常量字符串时，虚拟地址必须经过页表映射找到对应的物理内存，而在查表过程中发现其权限是只读，你想对其进行修改，就会在MMU内部触发硬件错误，操作系统在识别到是哪一个进程导致的之后，就会给该进程发送信号将其进行终止。

线程的优点：

• 创建一个新线程的代价要比创建一个新进程小的多。
• 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多。
• 线程占用的资源要比进程少很多。
• 能充分利用多处理器的可并行数量。
• 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务。
• 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。
• I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同I/O操作。

如何理解创建一个新线程的代价要比创建一个新进程小的多？

线程由于共享进程的资源，因此在创建和维护上的成本比进程要低。这使得线程适合于需要大量并发但资源共享的场景，而进程则更适合于需要独立资源和错误隔离的场景。

如何理解与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多？

线程之间的切换由于共享相同的地址空间和资源，需要操作系统做的工作比进程之间的切换要少很多，这使得线程切换更加高效。

如何理解计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现？

计算密集型应用是指那些主要依赖于CPU计算资源来完成其任务的应用程序，比如科学计算、图像处理、大数据分析、机器学习训练等。这类应用通常需要进行大量的数学运算和逻辑处理，对处理器的性能要求较高。在多处理器系统上运行计算密集型应用时，将计算分解到多个线程中实现，可以提高程序的执行效率和响应速度。

如何理解I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同I/O操作？

I/O密集型应用主要是指那些大部分时间都在等待I/O操作（如磁盘读写、网络通信等）完成的程序。这类应用的特点是CPU占用率相对较低，因为它们花费大量时间在等待I/O操作的完成。为了提高这类应用的性能，通常会采用多线程的策略来提高系统的相应速度。

线程的缺点

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

线程异常

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

线程用途

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

线程私有

• 线程的硬件上下文（CPU寄存器的值）（调度）
• 线程的独立栈结构（常规运行）

线程共享

• 代码和全局变量
• 进程文件描述符表

线程安全问题

一个线程出问题，导致其他线程也出了问题，导致整个进程退出，这叫做线程安全问题。

函数重入

多线程中，公共函数如果被多个线程同时进入，说明该函数被重入了。

Linux进程 VS 线程

进程和线程

进程是承担分配系统资源的基本实体，线程是调度的基本单位。

线程共享进程数据，但也拥有自己的一部分数据：

• 线程ID
• 一组寄存器（存储每个线程的上下文信息）
• 栈（每个线程都有临时数据，需要压栈出栈）
• errno（C语言提供的全局变量，每个线程都有自己的）
• 信号屏蔽字
• 调度优先级

进程的多个线程共享

同一地址空间，因此Text Segment、Data Segment都是共享的：

• 如果定义一个函数，在各线程中都可以调用
• 如果定义一个全局变量，在各线程中都可以访问到

除此之外，各线程还共享一下进程资源和环境：

• 文件描述符表（进程打开一个文件后，其他线程也能够看到）
• 每种信号的处理方式（SIG_IGN、SIG_DFL或者自定义的信号处理函数）
• 当前工作目录
• 用户ID和组ID

进程和线程的关系

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

Linux线程控制

POSIX线程库

• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的。
• 要使用这些函数库，要通过引入头文件<pthread.h>
• 链接这些线程函数库时要使用编译器命令的“-lpthread”选项。
• pthread线程库是应用层的原生线程库，应用层指的是这个线程库并不是系统接口直接提供的，而是由第三方帮我们提供的。原生指的是大部分Linux系统都会默认带上该线程库。

创建线程

• 功能： 创建一个新的线程
• 原型：

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，并且对全局变量erron赋值以指示错误。
• pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回。
• pthreads同样也提供了线程内的errno变量，以支持其他使用errno的代码。对于pthreads函数的错误，建议通过返回值来判定，因为读取返回值要比读取线程内的errno变量的开销更小。

让主线程创建一个新线程

当一个程序启动时，就有一个进程被操作系统创建，与此同时一个线程也立刻运行，这个线程叫做主线程。

• 主线程是产生其他子线程的线程。
• 通常主线程最后需要执行某些操作，例如各种关闭动作。

下面我们让主线程调用pthread_create函数来创建一个子线程，然后子线程就会去执行自己的代码，而主线程也会继续往后执行。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>void* Routine(void* arg)
{char* msg=(char*)arg;while(1){printf("I am %s\n",msg);sleep(1);}
}int main()
{pthread_t tid;pthread_create(&tid,NULL,Routine,(void*)"thread 1");while(1){printf("I am main thread!\n");sleep(2);}return 0;
}

运行结果如下：

当我们用ps axj命令查看当前进程的信息时，虽然此时该进程中有两个线程，但我们看到的进程只有一个，因为这两个线程都是属于这个进程的。

如果想看进程内的轻量级进程，可以使用ps -aL命令，可以显示当前的轻量级进程。

• 默认情况下，不带-L，看到的就是一个个进程。
• 带-L就可以查看到每个进程内的多个轻量级进程。

其中，LWP（Light Weight Process）就是轻量级进程的ID，可以看到显示的两个轻量级进程的PID是相同的，因为他们属于同一个进程。

注意： 在Linux中，应用层的线程与内核的LWP是一一对应的，实际上操作系统调度的时候采用的是LWP，而并非PID，只不过之前我们都是单线程进程，其PID和LWP的值是相同的，所以对于单线程进程来说，调度时采用PID和LWP是一样的。

为了进一步验证两个线程是属于同一个进程的，我们可以让主线程和子线程在进行操作时，打印各自的pid和ppid，通过pid和ppid就可以很明确的判断了。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>void* routine(void* arg)
{char* msg=(char*)arg;while(1){printf("I am %s,pid:%d,ppid:%d\n",msg,getpid(),getppid());sleep(1);}
}int main()
{pthread_t tid;pthread_create(&tid,NULL,routine,(void*)"thread 1");while(1){printf("I am main thread,pid:%d,ppid:%d\n",getpid(),getppid());sleep(2);}return 0;
}

可以看出来，主线程和子线程的pid和ppid都是一样的，也就是说他们虽然是两个执行流，但是属于同一个进程。

让主线程创建一批新线程

可以使用循环来创建一批线程，每个线程都可以调用Routine函数，说明Routine函数是可以被重入的。

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
const int threadnum=5;void* Routine(void* arg)
{char* name = (char*)arg;while(1){printf("I am %s...pid:%d,ppid:%d\n",name,getpid(),getppid());sleep(1);}
}int main()
{pthread_t tid[5];//保存五个线程的tidfor(int i=0;i<threadnum;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread-%d",i+1);pthread_create(&tid[i],NULL,Routine,buffer);}while(1){printf("I am main thread...pid:%d,ppid:%d\n",getpid(),getppid());sleep(2);}return 0;
}

这样就成功创建了一批线程：

因为主线程和子线程都属于同一个进程，所以pid和ppid都是一样的。

我们可以通过 ps -aL 来查看轻量级进程

由此可以查看到六个轻量级进程的LWP，主线程的LWP和PID相同。

LWP是内核中来标识一个执行流的唯一性，只在操作系统中使用。
而tid对应的是库中来维护的线程ID。

那么此时有个问题,新线程和主线程谁先运行？

答案是不确定，执行顺序是由调度器决定的。

此时我再运行一段代码，大家来看看运行效果，我们让子线程循环输出，然后主线程在创建完五个子线程之后等待2秒钟之后退出，猜猜最后子线程还会继续运行吗？

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
const int threadnum=5;void* Routine(void* arg)
{char* name = (char*)arg;while(1){printf("I am %s...pid:%d,ppid:%d\n",name,getpid(),getppid());sleep(1);}
}int main()
{pthread_t tid[5];//保存五个线程的tidfor(int i=0;i<threadnum;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread-%d",i+1);pthread_create(&tid[i],NULL,Routine,buffer);}sleep(2);return 0;
}

我们会发现，两秒之后整个程序都退出了，包括子线程。

由此可以得出：主线程退出 = 进程退出 = 所有线程都要退出
所以主线程都是需要最后再结束。

获取线程ID

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

获取线程ID有两种方法：

1. 创建线程时，通过输出型参数获得；
2. 使用pthread_self()函数获得；

pthread_t pthread_self(void);

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
const int threadnum=5;void* Routine(void* arg)
{char* name = (char*)arg;while(1){printf("I am %s...pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);}
}int main()
{pthread_t tid[5];for(int i=0;i<threadnum;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread-%d",i+1);pthread_create(&tid[i],NULL,Routine,buffer);printf("I am %s,tid:%lu\n",buffer,tid[i]);}while(1){printf("I am main...pid:%d,ppid:%d,tid:%lu\n",getpid(),getppid(),pthread_self());sleep(1);}return 0;
}

运行结果：

由此可见两种方式获得的线程ID相同。

注意： 用pthread_self函数获得的线程ID与内核LWP的值是不相等的，pthread_self函数获得的是用户级原生线程库的线程ID，而LWP是内核的轻量级进程ID，他们之间是一对一的关系。

线程等待

一个进程被创建出来，这个线程就如同进程一般，也是需要被等待的。如果主线程不对新线程进行等待，那么这个新线程的资源就不会被回收，就会导致类似“僵尸进程”的问题，也就是内存泄漏。

• 功能：等待线程结束
• 原型：

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

在下面的代码中我们先不关心线程的退出信息，直接将pthread_join函数的第二次参数设置为NULL，等待线程后打印该线程的编号以及线程ID。

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
const int threadnum=5;void* Routine(void* arg)
{char* name = (char*)arg;int cnt=3;while(cnt--){printf("I am %s...pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);}
}int main()
{pthread_t tid[5];for(int i=0;i<threadnum;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread-%d",i+1);pthread_create(&tid[i],NULL,Routine,buffer);}printf("I am main thread...pid:%d,ppid:%d\n",getpid(),getppid());for(int i=0;i<threadnum;i++){pthread_join(tid[i],NULL);printf("thread %d[%lu]\n",i,tid[i]);}return 0;
}

最后，子线程在执行3秒后成功退出了，然后主线程也是成功对五个子线程进行了等待。

接下来我们子线程退出时，可以自己设置一下退出时的退出码，这样成功等待之后会将线程的退出码进行输出。

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
const int threadnum=5;void* Routine(void* arg)
{char* name = (char*)arg;int cnt=3;while(cnt--){printf("I am %s...pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);}return (void*)111;
}int main()
{pthread_t tid[5];for(int i=0;i<threadnum;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread-%d",i+1);pthread_create(&tid[i],NULL,Routine,buffer);}printf("I am main thread...pid:%d,ppid:%d\n",getpid(),getppid());for(int i=0;i<threadnum;i++){void* ret=NULL;pthread_join(tid[i],&ret);printf("thread %d[%lu],exitcode: %d\n",i,tid[i],(int)ret);}return 0;
}

注意： pthread_join函数默认是以阻塞的方式进行线程等待的。

为什么线程退出时只能拿到线程的退出码？

如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过wait函数或是waitpid函数的输出型参数status，获取到退出进程的退出码、退出信号以及core dump标志。

那为什么等待线程时，我们只能拿到线程的退出码？难道线程不会出现异常吗？

线程在运行过程中当然也会出现异常，线程和进程一样，线程退出的情况也分为三种：

1. 代码运行完毕，结果正确。
2. 代码运行完毕，结果不正确。
3. 代码异常终止。

因此我们也需要考虑线程异常终止的情况，但是pthread_join函数无法获取到异常退出时的信息。因为线程是进程内的一个执行分支，如果进程中某个线程崩溃了，那么整个进程也就随之崩溃，我们就根本没有办法获取pthread_join函数，因为整个进程已经退出了。

例如我们在子线程中制造一个除零错误，那么程序执行到这里的时候程序就会崩溃，进而导致整个进程崩溃。

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>void* Routine(void* arg)
{char* msg = (char*)arg;int count = 0;while (count < 5){printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self());sleep(1);count++;int a = 1 / 0; //error}return (void*)2025;
}
int main()
{pthread_t tid[5];for (int i = 0; i < 5; i++){char* buffer = (char*)malloc(64);sprintf(buffer, "thread %d", i);pthread_create(&tid[i], NULL, Routine, buffer);printf("%s tid is %lu\n", buffer, tid[i]);}printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self());for (int i = 0; i < 5; i++){void* ret = NULL;pthread_join(tid[i], &ret);printf("thread %d[%lu]...quit, exitcode: %d\n", i, tid[i], (int)ret);}return 0;
}

所以pthread_join函数只能获取到线程正常退出时的退出码，用于判断线程的运行结果是否正确。

进程终止

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

1. 从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit；
2. 线程可以自己调用pthread_exit函数终止自己；
3. 一个线程可以调用phread_cancel函数终止同一进程中的另一个线程。

return 退出

在线程中使用return可以将该线程退出，在主函数中使用return表示整个进程退出。也就是说只要主线程退出了，就会释放该进程申请的资源，其他线程会因为没有资源，自然而然的也就退出了。

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
const int threadnum=5;void* Routine(void* arg)
{char* name = (char*)arg;while(1){printf("I am %s...pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);}return (void*)0;
}int main()
{pthread_t tid[5];for(int i=0;i<threadnum;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread-%d",i+1);pthread_create(&tid[i],NULL,Routine,buffer);printf("%s tid is %lu\n",buffer,tid[i]);}printf("I am main thread,pid:%d,ppid:%d,tid:%lu\n",getpid(),getppid(),pthread_self());return 0;
}

运行结果：

可以看出不能看到新线程执行的打印操作，因为主线程的退出导致整个进程退出了。

pthread_exit函数

• 功能：线程终止
• 原型：

void pthread_exit(void *value_ptr); 

• 参数：

  • value_ptr:value_ptr不要指向一个局部变量。

• 返回值：

  • 无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）。

• 注意点：

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

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<sys/types.h>void* Routine(void* arg)
{char* name=(char*)arg;int n=3;while(n--){printf("I am %s ,pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);}pthread_exit((void*)2025);
}int main()
{pthread_t tid[5];for(int i=0;i<5;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread %d",i);pthread_create(&tid[i],NULL,Routine,buffer);printf("%s tid is %lu\n",buffer,tid[i]);}printf("I am main thread,pid:%d,ppid:%d,tid:%lu\n",getpid(),getppid(),pthread_self());for(int i=0;i<5;i++){void* ret=NULL;pthread_join(tid[i],&ret);printf("thread %d[%lu] is quit,exitcode is:%d\n",i,tid[i],(int)ret);}return 0;
}

可以看出运行之后，获取的退出码就是我们设置的2025。

pthread_cancel函数

• 功能：取消一个执行中的线程
• 原型：

int pthread_cancel(pthread_t thread);

• 参数：
  • thread：线程ID
  • value_ptr：它指向一个指针，后者指向线程的返回值
• 返回值：成功返回0，失败返回错误码

线程是可以取消自己的，取消成功的线程的退出码一般是-1。例如在下面的代码中我们让子线程执行一次后就将自己取消。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<sys/types.h>void* Routine(void* arg)
{char* name=(char*)arg;int n=3;while(n--){printf("I am %s ,pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);pthread_cancel(pthread_self());}pthread_exit((void*)2025);
}int main()
{pthread_t tid[5];for(int i=0;i<5;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread %d",i);pthread_create(&tid[i],NULL,Routine,buffer);printf("%s tid is %lu\n",buffer,tid[i]);}printf("I am main thread,pid:%d,ppid:%d,tid:%lu\n",getpid(),getppid(),pthread_self());for(int i=0;i<5;i++){void* ret=NULL;pthread_join(tid[i],&ret);printf("thread %d[%lu] is quit,exitcode is:%d\n",i,tid[i],(int)ret);}return 0;
}

虽然线程可以自己取消自己，但是我们往往不会这么做，一般是利用一个线程去取消另外一个线程，比如主线程取消新线程。

例如下面的代码，我们用主线程创建五个新线程，然后再用主线程取消1、2、3号线程，

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<sys/types.h>void* Routine(void* arg)
{char* name=(char*)arg;int n=3;while(n--){printf("I am %s ,pid:%d,ppid:%d,tid:%lu\n",name,getpid(),getppid(),pthread_self());sleep(1);}pthread_exit((void*)2025);
}int main()
{pthread_t tid[5];for(int i=0;i<5;i++){char* buffer=(char*)malloc(64);snprintf(buffer,64,"thread %d",i);pthread_create(&tid[i],NULL,Routine,buffer);printf("%s tid is %lu\n",buffer,tid[i]);}printf("I am main thread,pid:%d,ppid:%d,tid:%lu\n",getpid(),getppid(),pthread_self());pthread_cancel(tid[0]);pthread_cancel(tid[1]);pthread_cancel(tid[2]);for(int i=0;i<5;i++){void* ret=NULL;pthread_join(tid[i],&ret);printf("thread %d[%lu] is quit,exitcode is:%d\n",i,tid[i],(int)ret);}return 0;
}

此时可以发现，0、1、2号线程因为被主线程退出了，所以最后的退出码不是我们设置的2025，而是-1，未被取消的3、4号线程的退出码是2025。

线程分离

• 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。
• 但如果我们不关心线程的返回值，join也是一种负担，此时我们可以将线程进行分离，后续当线程退出时就会自动释放线程资源。
• 一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧在该进程内运行，甚至这个线程崩溃了一定会影响其他线程，只不过这个线程退出时不再需要主线程去join了，当这个线程退出时，系统会自动回收该线程所对应的资源。

分离线程函数：pthread_detach

函数原型：

int pthread_detach(pthread_t thread);

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

int pthread_detach(pthread_self());

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

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<string.h>
#include<sys/types.h>
void* Routine(void* arg)
{pthread_detach(pthread_self());printf("%s\n",(char*)arg);return NULL;
}int main()
{pthread_t tid;if(pthread_create(&tid,NULL,Routine,"thread is running")!=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;
}

代码运行结果：

进程地址空间布局

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

在之前我们提到过，系统没有线程，只有轻量级进程的概念。但是用户可以通过接口，管理线程。比如创建、终止、等待等。因为这些都是在库内实现的，库做了封装。

线程局部存储

1. 线程虽然大部分资源是共享的，但是栈空间两个线程是独立的。
2. 在全局定义：int g_val=100; ，是在存储在初始化数据区域。即：一个线程修改g_val，另一个线程访问的g_val是修改过的。
3. 在全局定义：__thread int g_val=100; ，是在线程局部存储。即：一个线程修改g_val，另一个线程访问的g_val任然是100。
4. __thread 类似于一个编译选项，会将修饰的变量分别存储在每个线程的线程局部存储空间内。
5. 线程局部存储的作用和特点：
   • 多线程共用一个变量，但是想互不干扰。
   • 线程局部存储只能局部存储内置类型。