【Linux】多线程

---

一、Linux线程概念

1、什么是线程

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

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

每个进程都有自己独立的进程地址空间和独立的页表，也就意味着所有进程在运行时本身就具有独立性。
但如果我们在创建“进程”时，只创建task_struct，并要求创建出来的task_struct和父task_struct共享进程地址空间和页表，那么创建的结果就是下面这样的：

此时我们创建的实际上就是三个线程：

• 其中每一个线程都是当前进程里面的一个执行流，也就是我们常说的**“线程是进程内部的一个执行分支”**。
• 同时我们也可以看出，线程在进程内部运行，本质就是线程在进程地址空间内运行，也就是说曾经这个进程申请的所有资源，几乎都是被所有线程共享的。
• 单纯从技术角度，这个是一定能实现的，因为它比创建一个原始进程所做的工作更轻量化了。

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

所以什么是进程？这task_struct是线程，接下来我们看一下下图，蓝色框子里面的是进程：

因此，所谓的进程并不是通过task_struct来衡量的，除了task_struct之外，一个进程还要有进程地址空间、文件、信号等等，合起来称之为一个进程。
现在我们应该站在内核角度来理解进程：承担分配系统资源的基本实体，叫做进程。所以，当我们创建一个进程则是创建一个task_struct、进程地址空间和页表等，然后我们通过页表将虚拟内存和物理内存进行关联，同样，我们的物理内存还需要开辟空间建立映射，打开进程默认打开的相关文件、注册信号对应的处理方案等。

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

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

分清不了，也根本不需要去区分，因为cpu只区分是单个执行流还是多个执行流，CPU都是以task_struct为单位进行调度的。
单执行流调度：

多执行流调度：

既然CPU只关乎的是执行流是单个还是多个，那么，Linux下并不存在真正的多线程！而是用进程模拟的。

操作系统中有大量的进程，一个进程内又存在一个或多个线程，则线程的数量一定是比进程的数量多的，但是当线程的数量足够多的时候，线程的执行粒度是比进程细的，那么就是颗粒度更细。
而一款操作系统要想支持好线程，那么就需要对这些线程进行管理。比如创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等，所有的这一套相比较进程都需要另起炉灶，搭建一套与进程平行的线程管理模块。因此，如果要支持真的线程一定会提高设计操作系统的复杂程度。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。
但也有支持真的线程的操作系统，比如Windows操作系统，因此Windows操作系统系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂得多。

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

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

vfork函数是创建子进程，是父子共享空间，v函数fork的函数原型如下：

pid_t vfork(void);

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

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

共享？我们怎么在进程的时候说是独立的，而在线程说是共享？不信，那么我们设置一个全局变量g_val子进程将全局变量g_val由100改为了200，父进程休眠3秒后再读取到全局变量g_val的值，如果父进程读到的是100，那么就证明线程间是独立的，如果读到的是200，则证明是共享的，我们立马开始实验：

#include
#include 
#include 
#include 
int g_val = 100;
int main()
{
    pid_t id = vfork();
    if(id == 0)
    {
        // child
        g_val = 200;
        printf("child:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val);
        exit(0);
    }
    // father
    sleep(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下学习线程实际上就是学习在用户层模拟实现的这一套接口，而并非操作系统的接口。

2、二级页表

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

这张表就需要建立2^32 个虚拟地址和物理地址之间的映射关系，即这张表一共有2^32个映射表项。

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

每个应表项中存储一个物理地址和一个虚拟地址就需要8个字节，考虑到还需要包含权限相关的各种信息，这里每一个表项就按10个字节计算。这里一共有2的32次方个表项，也就意味着存储这张页表我们需要用2的32次方 * 10个字节，也就是40GB。而在32位平台下我们的内存可能一共就只有4GB，也就是说我们根本无法存储这样的一张页表。

因此所谓的页表并不是单纯的一张表。

以32位平台为例，其页表的映射过程如下：

1. 选择虚拟地址的前10个比特位在页目录当中进行查找，找到对应的页表。
2. 再选择虚拟地址的10个比特位在对应的页表当中进行查找，找到物理内存中对应页框的起始地址。
3. 最后将虚拟地址中剩下的12个比特位作为偏移量从对应页框的起始地址处向后进行偏移，找到物理内存中某一个对应的字节数据。

说明：

1. 物理内存实际是被划分成一个个4KB大小的页框的，而磁盘上的程序也是被划分成一个个4KB大小的页帧的，当内存和磁盘进行数据交换时也就是以4KB大小为单位进行加载和保存的。
2. 4KB实际上就是2的12次方个字节，也就是说一个页框中有2的12次方个字节，而访问内存的基本大小是1字节，因此一个页框中就有2的12次方个地址，于是我们就可以将剩下的12个比特位作为偏移量，从页框的起始地址处开始向后进行偏移，从而找到物理内存中某一个对应字节数据。

实际上页表就是个二级页表，一级页表是页目录，二级页表是页表项。

每一个表项我们还是按照10字节来进行计算，页目录和页表项还都是2的10次方个，因此一个表的大小就是2的10次方*10字节，也就是10KB，而页目录有2的十次方个表项那么就是对应的二级页表就也有2的10次方个，所以也就是一级页表有1个，二级页表有2的十次方张，一个页表是10KB，那么所有页表加起来为：（2的10次方+1）*10KB约等于10MB。内存消耗非常低，所以页表就是这么用的。
上面所说的所有映射过程，都是由**MMU（MemoryManagementUnit）**这个硬件完成的，该硬件是集成在CPU内的。页表是一种软件映射，MMU是一种硬件映射，所以计算机进行虚拟地址到物理地址的转化采用的是软硬件结合的方式。
注意：32位计算机下是二级页表，64位平台下用的是多级页表。

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

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

3、线程的优点

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

注释：

• 计算密集型：执行流的大部分任务，主要以计算为主。比如加密解密、大数据查找等。
• IO密集型：执行流的大部分任务，主要以IO为主。比如刷磁盘、访问数据库、访问网络等。

4、线程的缺点

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

5、线程异常

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

6、线程用途

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

二、Linux进程VS线程

1、进程和线程

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

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

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

2、进程的多个线程共享

因为是在同一个地址空间，因此所谓的代码段（Text Segment）、数据段（Data Segment）都是共享的：

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

各线程还共享以下进程资源和环境：

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

3、进程和线程的关系

三、Linux线程控制

1、POSIX线程库

pthread线程库是应用层的原生线程库：

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

错误检查：

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

2、线程创建

创建线程的函数叫做pthread_create

函数原型：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

参数说明：

• thread：获取创建成功的线程ID，该参数是一个输出型参数。
• attr：用于设置创建线程的属性，传入NULL表示使用默认属性。
• start_routine：该参数是一个函数地址，表示线程例程，即线程启动后要执行的函数。
• arg：传给线程例程的参数。

返回值说明：
线程创建成功返回1，创建不成功返回错误码。

主线程创建一个新线程

我们都知道，当一个程序启动时，就有一个进程被创建，与此同时一个线程也悄然被创建，我们称之为主线程。

• 主线程是产生其他子线程的线程。
• 通常主线程必须最后完成某些执行操作，比如各种关闭动作。

我们用主线程去创建一个新的线程，让新的线程去跑自己执行的新线程，而主线程跑自己的主线程，继续后面的代码。

#include 
#include 
#include 
#include 
//using namespace std;
// 新线程
void* Routine(void* _arg)
{
    char* msg = (char*)_arg;
    while(1)
    {
        std::cout << "I am new thread...my name is#" << msg << std::endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, Routine/*执行函数*/, (void*)"thread 0"/*传给线程参数*/);
    // 主线程
    while(1)
    {
        std::cout << "I am main thread...my pid is#" << getpid() << std::endl;
        sleep(2);
    }
    return 0;
}

注意这里的g++编译需要用到的是链接pthread静态库
命令：g++ -o thread thread.cc -std=c++11 -lpthread

运行代码后可以看到，新线程每隔一秒执行一次打印操作，而主线程每隔两秒执行一次打印操作。

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

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

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

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

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

我们为了进一步证明两个线程是一个进程的，那么我们在进行创建新线程完了以后我们打印一下pid和ppid即可：

主线程创建一批线程

#include 
#include 
#include 
#include 
#include 
//using namespace std;
// 新线程
void* Routine(void* _arg)
{
    char* msg = (char*)_arg;
    while(1)
    {
        std::cout << "I am new thread...my name is#" << msg << ":" << "my pid is#" << getpid() << "my ppid is#" << getppid() << std::endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid[5];
    for(int i = 0; i < 5; i++)
    {
        char* buff = (char*)malloc(64);
        sprintf(buff, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine/*执行函数*/, (void*)buff/*传给线程参数*/);
    }
    // 主线程
    while(1)
    {
        std::cout << "I am main thread...my pid is#" << getpid() << "my ppid is#" << getppid() <<std::endl;
        sleep(2);
    }
    return 0;
}

我们运行跑两次：主线程和五个新线程都属于同一个进程，所以它们的PID和PPID也都是一样的。

此时我们再用ps -aL命令查看，就会看到六个轻量级进程。

获取线程ID

常见获取线程ID的方式有两种：

• 创建线程时通过输出型参数获得。
• 通过调用pthread_self函数获得。

pthread_self原型如下：

pthread_t pthread_self(void);

调用pthread_self函数即可获得当前线程的ID，类似于调用getpid函数获取当前进程的ID。

下面代码中在每一个新线程被创建后，主线程都将通过输出型参数获取到的线程ID进行打印，此后主线程和新线程又通过调用pthread_self函数获取到自身的线程ID进行打印。

#include 
#include 
#include 
#include 
#include 
//using namespace std;
// 新线程
void* Routine(void* _arg)
{
    char* msg = (char*)_arg;
    while(1)
    {
        std::cout << "I am new thread...my name is#" << msg << ":" << "my pid is#" << getpid() << "my ppid is#" << getppid() << "tid#" << pthread_self() << std::endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid[5];
    for(int i = 0; i < 5; i++)
    {
        char* buff = (char*)malloc(64);
        sprintf(buff, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine/*执行函数*/, (void*)buff/*传给线程参数*/);
    }
    // 主线程
    while(1)
    {
        std::cout << "I am main thread...my pid is#" << getpid() << "my ppid is#" << getppid() << "tid#" << pthread_self() <<std::endl;
        sleep(2);
    }
    return 0;
}

注意这里打印的是tid的线程ID是不同的，说明其线程是分开的，进程是同一个进程进行共享地址空间的。

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

3、线程等待

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

等待线程的函数叫做pthread_join

原型如下：

int pthread_join(pthread_t thread, void **retval);

参数说明：

• thread：被等待线程的ID。
• retval：线程退出时的退出码信息。

返回值说明：
线程等待成功返回0，失败返回错误码。

调用该函数的线程将挂起等待，直到ID为thread的线程终止，thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的。

总结：

1. 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。
2. 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。
3. 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。
4. 如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。

常数PTHREAD_CANCELED是多少呢？我们通过grep去查一下：
可以发现PTHREAD_CANCELED实际上就是头文件里面的一个宏定义，它的值本质就是-1。

[Semi@hecs-91732 threadCreate]$ grep -ER "PTHREAD_CANCELED" /usr/include/

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

#include 
#include 
#include 
#include 
#include 
//using namespace std;
// 新线程
void* Routine(void* _arg)
{
    char* msg = (char*)_arg;
    int count = 0;
    while(count < 5)
    {
        std::cout << "I am new thread...my name is#" << msg << ":" << "my pid is#" << getpid() << "my ppid is#" << getppid() << "tid#" << pthread_self() << std::endl;
        sleep(1);
        count++;
    }
    return NULL;
}
int main()
{
    pthread_t tid[5];
    for(int i = 0; i < 5; i++)
    {
        char* buff = (char*)malloc(64);
        sprintf(buff, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine/*执行函数*/, (void*)buff/*传给线程参数*/);
    }
    // 主线程
    std::cout << "I am main thread...my pid is#" << getpid() << "my ppid is#" << getppid() << "tid#" << pthread_self() <<std::endl;
    for(int i = 0; i < 5; i++)
    {
        pthread_join(tid[i], NULL);
        printf("thread %d[%lu]quit\n", i, tid[i]);
    }
    return 0;
}

主线程创建的五个新线程在进行五次打印操作后就退出了，而主线程也是成功对这五个线程进行了等待。

我们接下来想要获取线程退出的退出码，我们将退出码返回一个很特殊的退出码看一下：
这里C++代码跑不过去，我们用C跑只会出现警告，不会错误。

#include 
#include 
#include 
#include 
#include 

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++;
	}
	return (void*)2024;
}
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函数默认是以阻塞的方式进行线程等待的。

我们发现下面的代码拿到了每个线程退出时的退出码信息。

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

如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过wait函数或是waitpid函数的输出型参数status，获取到退出进程的退出码、退出信号以及core dump标志。
那为什么等待线程时我们只能拿到退出线程的退出码？难道线程不会出现异常吗？
线程在运行过程中当然也会出现异常，线程和进程一样，线程退出的情况也有三种：

• 代码运行完毕，结果正确。
• 代码运行完毕，结果不正确。
• 代码异常终止。

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

那我们就在一个线程的执行例程中设置一个除零错误，当线程执行到除零这个错误的时候就崩了。

我们可以看下面的黑框框代码跑的过程，当我们make的时候已经出现除零告警了，而当我们运行这个可执行程序的时候，发现一个进程崩溃了以后珍格格进程都崩了，这也间接说明了多线程的一种不健壮性，这种不健壮性，导致我们也不确定是哪个线程出现错误了，一个线程除零错误导致的是整个进程的崩溃。所以pthread_join函数只能获取到线程正常退出时的退出码，用于判断线程的运行结果是否正确。

4、进程终止

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

• 从线程函数return。
• 线程可以自己调用pthread_exit函数终止自己。
• 一个线程可以调用pthread_cancel函数终止同一进程中的另一个线程。

（1）return退出

在线程中使用return代表当前线程退出，但是在main函数中使用return代表整个进程退出，也就是说只要主线程退出了那么整个进程就退出了，此时该进程曾经申请的资源就会被释放，而其他线程会因为没有了资源，自然而然的也退出了。

我们将主进程直接return退出看看效果：

#include 
#include 
#include 
#include 
#include 
// 实现函数
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++;
	}
	return (void*)2024;
}
int main()
{
    // 创建5个线程
	pthread_t tid[5];
	for (int i = 0; i < 5; i++)
    {
		char* buffer = (char*)malloc(64);
        // 写一下buffer进去
		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());
	// 直接退出 看看主进程退出后怎么个情形
    return 0;
}

看不到新线程打印的东西，而只能看到主进程立马退出了，没有任何的征兆。

（2）pthread_exit函数

pthread_exit函数的功能就是终止线程，pthread_exit函数的函数原型如下：

void pthread_exit(void *retval);

参数说明：

• retval：线程退出时的退出码信息。

说明：

• 该函数无返回值，跟进程一样，线程结束的时候无法返回它的调用者（自身）。
• pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其他线程得到这个返回指针时，线程函数已经退出了。

我们使用pthread_exit函数终止进程，并设置退出码是2025。

#include 
#include 
#include 
#include 
#include 
// 实现函数
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++;
	}
	pthread_exit((void*)2025);
}
int main()
{
    // 创建5个线程
	pthread_t tid[5];
	for (int i = 0; i < 5; i++)
    {
		char* buffer = (char*)malloc(64);
        // 写一下buffer进去
		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;
}

我们发现退出码是2025了。

小知识：exit函数的作用是终止进程，任何一个线程调用exit函数也代表的是整个进程终止。

（3）pthread_cancel函数

线程是可以被取消的，我们可以使用pthread_cancel函数取消某一个线程，pthread_cancel函数的函数原型如下：

int pthread_cancel(pthread_t thread);

参数说明：

• thread:被取消线程的ID

返回值说明：

• 线程取消成功返回0，失败返回错误码。

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

#include 
#include 
#include 
#include 
#include 
// 实现函数
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++;
        // 第一次就线程取消
        pthread_cancel(pthread_self());
	}
    // 退出码
	pthread_exit((void*)2025);
}
int main()
{
    // 创建5个线程
	pthread_t tid[5];
	for (int i = 0; i < 5; i++)
    {
		char* buffer = (char*)malloc(64);
        // 写一下buffer进去
		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;
}

我们发现新的被创建的线程只打印了一次就退出了，并且其退出码是-1而不是我们规定的2025，因为我们是在线程执行pthread_exit函数前将线程取消的。

但一般都不会自己进程取消自己进程，因为没必要，所以我们往往都是用一个线程去取消另一个线程，比如主线程去取消新创建的线程。

比如我们写一个主线程在创建完5个新线程之后，取消0，1，2，3这四个线程就留一个4号线程我们看一下：

#include 
#include 
#include 
#include 
#include 
// 实现函数
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++;
	}
    // 退出码
	pthread_exit((void*)2025);
}
int main()
{
    // 创建5个线程
	pthread_t tid[5];
	for (int i = 0; i < 5; i++)
    {
		char* buffer = (char*)malloc(64);
        // 写一下buffer进去
		sprintf(buffer, "thread %d", i);
		pthread_create(&tid[i], NULL, Routine, buffer);
		printf("%s tid is %lu\n", buffer, tid[i]);
	}
    // 取消0 1 2 3四个线程
    pthread_cancel(tid[0]);
    pthread_cancel(tid[1]);
    pthread_cancel(tid[2]);
    pthread_cancel(tid[3]);
    // 打印一下
	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;
}

此时可以发现，0、1、2、3号线程退出时的退出码不是我们设置的6666，而只有未被取消的4号线程的退出码是2025，因为只有4号进程未被取消。

既然主线程能够终止新线程，那么新线程能不能终止主线程呢？当然了，当然是可以了，我们在新线程中将主线程给退出：

#include 
#include 
#include 
#include 
#include 
// 定一个全局变量，大家都能拿得到
pthread_t main_pthread;
// 实现函数
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++;
        // 取消主线程
        pthread_cancel(main_pthread);
	}
    // 退出码
	pthread_exit((void*)2025);
}
int main()
{
    // 找一下主线程的pthread_self
    main_pthread = pthread_self();
    // 创建5个线程
	pthread_t tid[5];
	for (int i = 0; i < 5; i++)
    {
		char* buffer = (char*)malloc(64);
        // 写一下buffer进去
		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;
}

监视命令行：

[Semi@hecs-91732 threadCreate]$ while :; do ps -aL | head -1&&ps -aL | grep mythread | grep -v grep;echo "###############";sleep 1;done

可以看到一段时间后，六个线程中PID和LWP相同的线程，也就是主线程右侧显示< defunct >，也就意味着主线程已经被取消了，我们也就看不到后续主线程等待新线程时打印的退出码了。

注意：

• 当采用这种取消方式时，主线程和各个新线程之间的地位是对等的，取消一个线程，其他线程也是能够跑完的，只不过主线程不再执行后续代码了。
• 我们一般都是用主线程去控制新线程，这才符合我们对线程控制的基本逻辑，虽然实验表明新线程可以取消主线程，但是并不推荐该做法。

5、分离线程

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

（1）pthread_detach

用来分离线程的函数，我们的函数原型如下：

int pthread_detach(pthread_t thread);

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

参数说明：

• thread：被分离线程的ID。

返回值说明：

• 线程分离成功返回0，失败返回错误码。

下面我们创建五个新线程后让这五个新线程将自己进行分离，那么此后主线程就不需要在对这五个新线程进行join了。

#include 
#include 
#include 
#include 
#include 
// 实现函数
void* Routine(void* arg)
{
    pthread_detach(pthread_self());
	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++;
	}
    // 退出码
	pthread_exit((void*)2025);
}
int main()
{
    // 创建5个线程
	pthread_t tid[5];
	for (int i = 0; i < 5; i++)
    {
		char* buffer = (char*)malloc(64);
        // 写一下buffer进去
		sprintf(buffer, "thread %d", i);
		pthread_create(&tid[i], NULL, Routine, buffer);
		printf("%s tid is %lu\n", buffer, tid[i]);
	}
    // 打印一下
    while(1)
    {
	    printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self());
        sleep(1);
    }

	return 0;
}

这五个新线程在退出时，系统会自动回收对应线程的资源，不需要主线程进行join。

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

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

1、pthread_t是什么类型，何许人也？

首先，Linux不提供真正的线程，只提供LWP，也就意味着操作系统只需要对内核执行流LWP进行管理，而供用户使用的线程接口等其他数据，应该由线程库自己来管理，因此管理线程时的“先描述，再组织”就应该在线程库里进

我们通过ldd命令看一下线程库是什么：

进程运行时动态库被加载到内存，然后通过页表映射到进程地址空间中的共享区，此时该进程内的所有线程都是能看到这个动态库的。

我们说每个线程都有自己私有的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。除此之外，每个线程都有自己的struct pthread，当中包含了对应线程的各种属性；每个线程还有自己的线程局部存储，当中包含了对应线程被切换时的上下文数据。
每一个新线程在共享区都有这样一块区域对其进行描述，因此我们要找到一个用户级线程只需要找到该线程内存块的起始地址，然后就可以获取到该线程的各种信息。

上面我们所用的各种线程函数，本质都是在库内部对线程属性进行的各种操作，最后将要执行的代码交给对应的内核级LWP去执行就行了，也就是说线程数据的管理本质是在共享区的。
pthread_t到底是什么类型取决于实现，但是对于Linux目前实现的NPTL线程库来说，线程ID本质就是进程地址空间共享区上的一个虚拟地址，同一个进程中所有的虚拟地址都是不同的，因此可以用它来唯一区分每一个线程。

2、地址形式对线程ID进行打印

#include 
#include 
#include 
void* Routine(void* arg)
{
    while(1)
    {
        printf("new thread:%p\n", pthread_self());
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, Routine, NULL);
    while(1)
    {
        printf("main thread#%p\n", pthread_self());
        sleep(2);
    }
    return 0;
}

本质就是地址：