一. 线程库

在Linux下，并没有真正的线程，只有用进程模拟的轻量级进程，所以Linux并没有提供可以直接创建线程的接口，但是通过进程模拟的轻量级进程，在用户感知和操作方面，和线程没有区别，所以Linux可以实现多线程
Linux提供了一个pthread — 线程库。如果需要实现多线程，那么在编译时就需要链接pthread这个动态库。使用时也需要包含pthread.h这个头文件
Linux默认都自带这个动态库

ldconfig -p | 库名 查看库的所处路径

二. 多线程操作

介绍完线程库，接下来我们就来学习几个线程操作

ps -aL 可以查看当前所有线程

1. 线程创建

线程创建的函数：pthread_create()

有四个参数，我们一一分析

参数	作用
pthread_t *thread	返回线程ID（输出型参数）
const pthread_attr_t *attr	设置线程属性（一般传nullptr，表示默认属性）
void*(start_routine)(void)	参数和返回值都是void*的函数指针，为线程的启动函数
void*arg	传给线程启动函数的参数

我们编写一个简单程序演示该函数的使用

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

#define NUM 10 // 创建线程的个数

//线程的启动函数
void* thread_run(void*args)
{
	//tname内容会传给args
	//因为args是void*类型，所有类型都可以接受
    char*tname=(char*)args;
    for(int i=0;i<2;i++)
    {
        cout<<"I am the "<<tname;
        sleep(1);
    }
    
   return nullptr;
}

int main()
{
    cout<<"I am the main stream"<<endl;
    sleep(1);
    pthread_t pth[NUM];

    for(int i=0;i<NUM;i++)
    {
    	//我们给启动函数传入线程编号
    	//格式：pthread[i]
        char tname[64];
        snprintf(tname,sizeof(tname),"pthread[%d]\n",i+1);
        
        pthread_create(pth+i,nullptr,thread_run,tname);
    }
    
    sleep(4);
    cout<<"多线程运行完毕"<<endl;

    return 0;
}

运行结果如下：

PS：编译时需要链接pthread动态库

接下来，对上述程序做些解释

程序的目的是，创建10个线程，并通过传参，让每个线程打印内容，打印的内容是形式为 " I am the pthread[i] "

1. 第一步，创建线程的第一个参数， pthread_t * thread 是一个输出型参数，我们要创建10个线程，所以要准备10个pthread_t ，所以我们提供一个pthread_t 数组，大小为10，pthread_t 本质是长整型
   
2. 线程是通过执行启动函数实现的，启动函数必须是返回值，参数都为void* 的一个函数，所以我们编写thread_run，同时pthread_create的最后一个参数void* arg是回调的参数，其会被传值给thread_run，所以args会接收arg。我们可以通过这个参数，传递我们想让线程完成的任务
3. 我们想让线程打印的内容就可以通过arg传递过去，所以我们使用snprintf动态的传递一个字符串给thread_run启动函数，void * 可以接收任意类型，但是在使用时需要强转一下类型

但是运行结果怎么都是pthread[10]？
这是因为我们此时使用的是char* 临时变量，每次都被新的snprintf覆盖，而因为CPU运行过快，所以直接覆盖成最后的10，所以线程拿到的都是地址，访问都是同一块空间。
我们要想每次线程拿到的都是新的地址，可以使用new申请堆空间

并且在启动函数中，我们使用完该堆区空间，还需要释放空间

运行结果如下：

我们还注意到一个现象，那就是并不是先创建的线程就先运行。实际上，线程的执行顺序由调度器决定，主线程和此线程在无其他干扰时也是如此，谁先调度由调度器决定。

---

我们再看一个现象

我们让线程一直运行，而主线程创建10个线程后就结束，结果是如何呢？

我们看到，线程都是运行了一次，然后程序就终止了
我们得出的结论是：主线程退出，相当于进程退出，进程退出，操作系统会回收分配给进程的资源，资源被回收，那么线程们也就无法运行，所以也终止了。

这一点与进程退出，子进程也退出成为孤儿进程，有些类型。

---

2. 线程等待

线程可以退出，那么自然主线程可以获取其退出信息

线程等待的函数是：pthread_join()

参数	作用
pthread_t * thread	线程ID
void ** retval	返回线程的返回信息（输出型参数）

第一个参数是线程的ID
第二个参数其实就是启动函数的返回值，我们需要在主线程定义一个void*，来接收线程的返回值，因为需要修改void*的内容，所以参数是二级指针

我们举例以下程序，进行说明

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

#define NUM 5

//启动函数
//需要返回值和参数都是void*
void* thread_run(void*args)
{
    char*tname=(char*)args;
    for(int i=0;i<2;i++)
    {
        cout<<"I am the "<<tname;
        sleep(1);
    }
    
    delete tname;
    
    return (void*)10;
}

int main()
{
    cout<<"I am the main stream"<<endl;
    pthread_t pth[NUM];

    for(int i=0;i<NUM;i++)
    {
        // char tname[64];
        char *tname=new char[64];
        snprintf(tname,64,"pthread[%d]\n",i+1);
        pthread_create(pth+i,nullptr,thread_run,tname);
    }

    //接收返回的信息
    void*ret=nullptr;
    //线程等待
    for(int i=0;i<NUM;i++)
    {
        pthread_join(pth[i],&ret);
        cout<<"获取的退出信息:"<<(int_fast64_t)ret<<endl;
    }

    cout<<"多线程运行完毕"<<endl;
    
    return 0;
}

程序大致相同，我们这次只创建5个线程，但是在主线程中，我们使用pthread_join等待线程退出，同时创建void* ret接收线程退出的返回信息。
在线程的启动函数中，我们返回(void*)10

运行结果如下：

所以我们传过去的ret，会成为输出型参数，接收线程退出的返回值。

---

3. 线程退出

线程退出和return 类似
退出的函数是：pthread_exit()

参数	作用
void * retval	返回线程的返回信息

pthread_exit的使用类似return

4. 线程取消

线程取消的函数是：pthread_cancel()
可以通过pthread_self()函数获取当前线程的ID

线程取消

参数	作用
pthread_t thread	线程ID

获取线程ID

pthread_cancel一般既可以由需终止的线程自己执行，也可以主线程调用，来终止该线程。不建议在子线程里终止主线程。

我们使用ps -aL可以查看当前运行的线程

当线程后跟上< defunct >，表示该线程是僵尸线程，即其父线程没有回收该线程。

线程取消的方法是向目标线程发送CANCEL信号，但如何处理CANCEL信号则由目标线程自己决定，或者忽略，或立刻终止，或者继续运行值Cancelation-point（取消点），由不同的Cancekation状态决定。线程收到CANCEL信号的默认方式（即pthread_create()创建线程第二个参数为nullptr时），是继续运行至取消点，也就是说设置一个CANCELED状态，线程继续运行，只有运行至Cancelation-point的时候才会出现
pthread_join就是设置取消点的一种方式

PS： 如果一个子线程是被pthread_cancel取消的，那么该线程的返回值是PTHREAD_CANCELED，其实是(void*)-1

5. 线程分离

我们上面讲了主线程可以回收线程资源，需要线程等待。
其实创建一个线程，该线程中的属性默认是joinable的，也就是退出时，需要主线程回收资源，也就是pthread_join。否则无法释放资源，导致系统泄漏。
但是如果主线程不关心该线程的返回值，不想等待回收，那么我们可以分离该线程，也就是将该线程的属性从joinable改成detached
线程分离的函数是：pthread_detach()

参数	作用
pthread_t thread	线程ID

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

PS：pthread_join和pthread_detach是冲突，一个线程如果已经分离，那么再对其进行等待会失败。

我们简单编写一段代码，展示该现象

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string>
#include<cstring>
#include<ctime>

using namespace std;


//启动函数
void* thread_run(void*args)
{
    while(true)
    {
        cout<<"线程运行中..."<<endl;
        sleep(1);
    }

    pthread_exit((void*)10);
}


 int main()
{
    cout<<"I am the main stream"<<endl;
    //线程ID
    pthread_t pth;
    //创建线程
    pthread_create(&pth,nullptr,thread_run,nullptr);
    //线程分离
    pthread_detach(pth);
    sleep(1);
    //线程等待
    int n=pthread_join(pth,nullptr);
    if(n!=0)
    {
        cerr<<"errno: "<<strerror(n)<<endl;
    }
    
    cout<<"主线程退出..."<<endl;
    return 0;
}

PS：此处我们先分离再等待。因为线程等待其实需要检查目标线程的属性，如果是joinable，则等待，如果是detached，则会失败。而失败则会返回错误码。

运行结果如下：

我们看到分离后再等待，pthread_join返回错误码，错误为Invalid argument

6. 返回值

线程操作大部分返回值的描述都是这样的

我们以pthread_create作为举例

成功返回0，错误返回错误码
在大部分系统调用的返回值中，是成功返回0，错误设置错误码，也就是C语言的全局变量errno
但是因为多线程共享全局变量，所以每个线程错误都设置错误码的话，可以会互相影响，所以线程操作不设置错误码，而是返回错误码

三. 多线程理解

我们知道，动态库是在程序运行时，会加载到内存中，然后映射到虚拟地址空间的共享区。线程库为动态库，所以同样会映射到共享区中。
为了后续的理解，我们举个文件系统的例子作铺垫：
我们知道，打开文件在系统调用接口式open()，在C语言中是fopen，在C++中是fstream。
在操作系统层面，文件管理是文件描述符，在C语言中是struct FILE结构体，在C++中是类。

但是其实在语言层面只是对系统调用接口的封装，而线程库其实也是对系统调用接口的封装
pthread_create其实就是对clone的封装。
所以线程库同语言库，也需要对线程进行管理，所以在线程库中有管理线程的结构体

mmap区域就是共享区

线程在内核中的编号是LWP，但我们通过pthread_self()返回的是线程ID，和LWP并不同。
线程库中的线程ID其实是一个虚拟地址，指向该管理该线程结构体的起始地址。

线程栈
线程创建的临时变量会存储在线程栈中，也叫独立栈。
主线程的栈是虚拟地址的栈。

栈的存储其实使用了两个寄存器，一个是ebp寄存器，一个是esp寄存器

ebp寄存器记录栈区的开始，不会改变
esp寄存器记录栈区的结束，会随着栈区数据增多而向下扩展
切换栈区，其实就是切换ebp和esp寄存器。

线程局部存储

当多个线程使用主线程创建的全局变量时，如果要互补影响，可以将该全局变量拷贝一份到线程局部存储中。
gcc/g++实现的方式是在全局变量前加__thread。如：

__thread int g_val=100;

结束语

本篇内容到此就结束了，感谢你的阅读!

如果有补充或者纠正的地方，欢迎评论区补充，纠错。如果觉得本篇文章对你有所帮助的话，不妨点个赞支持一下博主，拜托啦，这对我真的很重要。