[系统运维] Linux多线程

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> Linux多线程 -> 正文阅读

[系统运维]Linux多线程

文章目录

- - Linux多线程

Linux多线程

Linux线程概念

什么是线程

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

一般在Linux教材里面线程是这样定义的：

线程：是在进程内部运行的一个执行分支（执行流），属于进程的一部分，粒度要比进程更加细和轻量化。

按照上面教材的这种说法，我现在有一些问题：

一个进程内可能存在多个线程？

这是可能呢。

进程:线程 = 1:n

在OS中存在这么多的线程，那么OS要不要管理线程呢？如何管理呢？

答案是肯定要管理的，六字真言：先描述，再组织。

因此我们就可以得出一个推论：线程也应该要有线程控制块TCB

的确，我们window下的多线程就是这样子做的

但是我们Linux下的多线程并没有像上面说的那样通过创建数据结构，然后通过管理数据结构从而达到管理线程的目的。那我们Linux下的多线程是怎么做的呢？

我们先来回顾一下进程，我们知道创建一个进程，我们需要为它创建一些列的数据结构，比如说：PCB(进程控制块)、mm_struct(进程地址空间)、页表和file_struct等等

在这里插入图片描述

那如果我们在创建进程时，只创建task_struct，将那个创建出来的进程的task_struct和父进程的task_struct共享虚拟地址空间和页表，并将父进程的资源（代码+数据），划分为若干份，让每个task_struct使用会是怎么样的呢？

下面我们一起来看一下下面的这张图片

在这里插入图片描述

CPU此时看到的PCB是<=我们之前讲的PCB的概念的，在CPU看来一个PCB就是一个需要被调度的执行流。这就是我们Linux下的线程，Linux中并没有像windows下为线程专门设计TCP，而是使用进程PCB来模拟线程。

那Linux这样做有什么好处呢？

不用维护复杂的进程和线程的关系，不用单独为线程涉及任何算法，直接使用进程的一套相关的方法，OS只需要聚焦在线程间的资源分配上就可以了。

现在我们再来理解一下上面教材说的：线程是在进程内部运行的一个执行分支，这里的内部是什么意思呢？，那什么又叫做一个执行分支呢？

这里的内部指的是线程是在进程的虚拟地址空间中运行的。执行分支指的是CPU调度的时候只看PCB，每一个PCB曾经被指派过指向方法和数据，CPU是可以直接调度的。

在今天了解了Linux下的线程之后，我们又该如何理解我们之前讲的进程呢？

下面用绿色方框圈起来的内容，我们将这个整体叫做进程

在这里插入图片描述

之前的进程，内部只有一个执行流，今天的进程，内部可以具有多个执行流。创建进程的"成本非常高"，成本：时间+空间，创建一个进程要使用的资源是非常多的（0-1），我们从内核视角来看进程就是承担分配系统资源的基本实体！！线程就是CPU调度的基本单位，承担进程资源的一部分的基本实体，进程划分资源给线程。总得来说 Linux下的线程就是轻量级进程。

线程的优点

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

线程的缺点

性能损失

一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
健壮性降低

编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
缺乏访问控制

进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
编程难度提高

编写与调试一个多线程程序比单线程程序困难得多

线程异常

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

线程用途

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

Linux下的进程VS线程

进程和线程

进程是资源分配的基本单位
线程是调度的基本单位
线程虽然共享进程数据，但也拥有自己的一部分数据:
- 线程ID
- 一组寄存器(保护CPU调度时存放在寄存器中的临时数据)
- 栈(保护线程运行时所形成的临时数据)
- errno
- 信号屏蔽字
- 调度优先级

进程的多个线程共享

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

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

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

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

进程和线程的关系

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

在这里插入图片描述

在之前我们接触到的是单线程进程或者多个单线程进程。

Linux线程控制

POSXI线程库

与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
要使用这些函数库，要通过引入头文<pthread.h>
要链接这些线程函数库时要使用编译器命令的“-lpthread”选项

错误检查：

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

线程创建

创建线程的函数叫做pthread_creat

功能： 创建一个新的线程

函数原型如下：

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，创建失败返回错误码

下面我们来一起使用一下这个函数

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

using namespace std;

void* Running (void* arg)
{
    char* str = (char*)arg;
    while(true)
    {
        cout<<"I am"<<str<<endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,Running,(void*)"new thread");
    while(true)
    {
        cout<<"I am main thread"<<endl;
        sleep(1);
    }
    return 0;
}

运行结果：

在这里插入图片描述

那我现在有一个问题：我该如何获得一个线程的ID呢？

下面再来介绍一个函数——pthread_self()

函数功能： 获得该线程自身的ID

函数原型如下：

pthread_t pthread_self(void);

下面我们再来使用一下这个函数

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

using namespace std;

void* Running (void* arg)
{
    char* str = (char*)arg;
    while(true)
    {
        cout<<"I am"<<str<<"我的线程ID是："<<pthread_self()<<endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,Running,(void*)"new thread");
    while(true)
    {
        cout<<"I am main thread,我创建的线程ID是："<<tid<<endl;
        sleep(1);
    }
    return 0;
}

运行结果：

在这里插入图片描述

可以看到我们主线程创建的线程的线程ID和新线程ID是一样的。

我们还可以通过ps -aL命令来查看我们启动的线程

在这里插入图片描述

其中这里的LWP（light weight process）就是我们轻量级进程的ID，可以看到我们刚刚启动的那两个线程他们的pid是一样的，这是因为它俩属于同一个进程，其中有一个线程的LWP和pid是一样的，这个线程是我们的主线程。

我现在有一个问题： 今天学了多线程之后，我明白CPU调度的基本单位是线程，可是我之前调度都是用进程的pid去调度的，那为什么没有出错呢？

这是因为我们之前碰到都是单线程进程或者多个单线程进程，当我们是单线程进程的时候我们进程的pid和这个主线程的LWP是一样的，因此即使你用进程的pid去调度那也是没有错的！！

我现在还有一个问题：你说Linux没有为多线程创建TCB，而是使用轻量级进程来模拟线程这我可以理解，那为什么这里的LWP——轻量级进程的ID和我们上面使用pthread_self()函数显示的线程ID却是不一样的呢？

这是因为pthread_self()函数获得的是用户级原生线程库的线程ID，而LWP获取的是内核的轻量级进程ID，它们之间是一对一的关系，因此它们显示出来的线程ID是不一样的。

我现在还有一个问题：如何创建一个线程我已经学会了，那我应该一次如何创建多个线程呢？

下面就来教你如何一次创建多个线程

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

using namespace std;

void* Running (void* arg)
{
    char* msg = (char*)arg;
    while(true)
    {
        cout<<"I am "<<msg<<"pid 是："<<getpid()<<"我的线程ID是: "<<pthread_self()<<endl;
        sleep(2);
    }
}

int main()
{
    pthread_t tid[5];
    for(int i = 0;i<5;i++)
    {
       char* buffer = (char*)malloc(64);
       fprintf(buffer,"thread %d",i);
       pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    while(true)
    {
        cout<<"I am main thread "<<"pid 是: "<<"我的线程ID是："<<pthread_self()<<endl;
        sleep(1);
    }
    return 0;
}

运行结果：

在这里插入图片描述

可以看到这些线程的线程ID都是不一样的，但是它们的pid都是一样的，由此可以得出他们都是一个进程创建出来的线程。

下面我们再通过ps -aL命令来看一下

在这里插入图片描述

可以看到这群轻量级进程的pid同样都是15432.

线程等待

我们创建进程是为了让进程去帮我们完成一些任务的，同样的我们创建线程也是想让线程去帮我们完成一些任务。我们如果想知道我们给进程派发的任务它完成的怎么样，我们需要等待该进程然后查看这个进程的退出码之类的信息，否则该进程有可能会变成僵尸进程。那对于线程而言我们需要等待嘛？一般而言，线程也是需要被等待的，如果不等待，可能会导致类似于“僵尸进程”的问题。

下面来给大家介绍一个线程等待的函数——pthread_join()

功能： 等待一个线程结束

pthread_join函数的函数原型如下;

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

参数：

thread：被等待线程的线程ID
retval：输出型参数，用来获取新线程退出的时候，函数的返回值

返回值：

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

下面我们就来使用一下这个函数吧

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

using namespace std;

void* Running(void* arg)
{
    char* msg = (char*)arg;
    while(true)
    {
        cout<<"I am "<<msg<<" "<<"pid 是:"<<getpid()<<"我得线程ID是"<<pthread_self()<<endl;
        sleep(5);
        break;
    }
    return (void*)222;
}

#define NUM 1

int main()
{
    pthread_t tid[NUM];
    fpr(int i = 0;i<NUM;i++)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer,"thread %d",i);
        pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    void* ret = nullptr;
    pthread_join(tid[0],&ret);
    
    //这里能够达到退出码的原因是：ret是指向Running函数的返回值的，我们将222通过强转成(void*)它其实就可以看作是一个指针
    //然后它里面存的就是222，因此我们这里拿到ret的前八个字节就能够拿到这里的返回值
    cout<<"新线程退出码: "<<(long)ret<<endl;
    
    return 0;
}

运行结果：

在这里插入图片描述

可以看到我们通过等待之后如愿的拿到了新线程的退出码，这里还需要说明一下，我们这里的join函数默认是以阻塞方式进行等待的，如果你不关心线程的退出码的话，只需要将join函数的第二个参数设置为nullptr即可。

我们之前学习进程等待的时候，我们可以通过wait函数或者是waitpid函数的输出型参数status，获取到进程的退出码、退出信号以及core dump标志。

我们的线程和进程一样，退出无非就以下三种情况：

代码跑完，结果正确
代码跑完，结果不正确
代码异常了

我们可以通过join的第二个参数拿到线程的返回值，从而知道线程跑完，结果正确还是不正确。那我们的pthread_join能或者需要处理代码异常的情况嘛？根本就不需要，因为线程是进程的一个执行分支，如果进程中的某个线程崩溃了，会导致整个进程都崩溃，因此这根本就不是我们线程该管的事情，要管也是交给进程去管。

线程终止

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

从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
线程可以调用pthread_ exit函数终止自己。
一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。

下面我们就来介绍一下上面的三种方法

return退出

在线程函数中使用return表示当前线程退出，如果在main函数中使用return则代表进程退出，也就是说只要主线程退出了就相当于这个进程也就推出了，此时我们进程曾经申请的那些资源都会被释放，然后它缩创建的那些线程也会自动退出。

下面我们就来使用一下这种方法

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

using namespace std;

void* Running(void* arg)
{
    char* msg = (char*)arg;
    while(true)
    {
        cout<<"I am "<<msg<<" "<<"pid 是:"<<getpid()<<"我得线程ID是"<<pthread_self()<<endl;
        sleep(5);
        break;
    }
    return (void*)123;
}

#define NUM 1

int main()
{
    pthread_t tid[NUM];
    fpr(int i = 0;i<NUM;i++)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer,"thread %d",i);
        pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    void* ret = nullptr;
    pthread_join(tid[0],&ret);
    
    cout<<"新线程退出码: "<<(long)ret<<endl;
    
    return 0;
}

运行结果：

在这里插入图片描述

pthread_exit函数终止线程

除了上面return可以终止线程外，下面我们再来介绍一个函数——pthread_exit()

功能： 终止一个线程

函数原型如下：

void pthread_exit(void *retval);

参数：

retval：不要指向一个局部变量

返回值：

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

注意：

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

下面我们来使用一下这个函数

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

using namespace std;

void* Running(void* arg)
{
    char* msg = (char*)arg;
    int num = 0;
    while(true)
    {
        num++;
        sleep(1);
        cout<<"I am "<<msg<<" "<<"pid 是:"<<getpid()<<"我得线程ID是"<<pthread_self()<<endl;
        if(num==5)
        {
            break;
        }
    }
   pthread_exit((void*)123);
}

#define NUM 1

int main()
{
    pthread_t tid[NUM];
    fpr(int i = 0;i<NUM;i++)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer,"thread %d",i);
        pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    void* ret = nullptr;
    pthread_join(tid[0],&ret);
    
    cout<<"新线程退出码: "<<(long)ret<<endl;
    
    return 0;
}

运行结果：

在这里插入图片描述

可以看到我们使用pthread_exit函数也终止了进程，这个时候可能就会有人问了，那我们使用exit可不可以呢？答案是不行的，exit是终止进程的，如果你在任何一个线程函数的内部调用exit函数都会导致整个进程被终止，进程都被终止了，该进程所创建的所有线程也都会被终止，所以使用exit是不行的。

pthread_cancel函数取消线程

除了上面两种方法外，其实还有一种方法可以终止进程，下面再来为大家介绍一个函数——pthread_cancel()

功能： 取消一个正在执行中的线程

函数原型如下：

int pthread_cancel(pthread_t thread);

参数：

thread：线程ID

返回值：

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

下面我们来使用一下这个函数

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

using namespace std;

void* Running(void* arg)
{
    char* msg = (char*)arg;
    while(true)
    {
        sleep(1);
        cout<<"I am "<<msg<<" "<<"pid 是:"<<getpid()<<"我得线程ID是"<<pthread_self()<<endl;
    }
}

#define NUM 1

int main()
{
    pthread_t tid[NUM];
    fpr(int i = 0;i<NUM;i++)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer,"thread %d",i);
        pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    cout<<"wait sub thread..."<<endl;
    sleep(5);
    cout<<"cancel sub thread..."<<endl;
    pthread_cancel(tid[0]);
    
    void* ret = nullptr;
    pthread_join(tid[0],&ret);
    
    cout<<"新线程退出码: "<<(long)ret<<endl;
    
    return 0;
}

? 运行结果：

在这里插入图片描述

我们可以看到一个线程如果是被取消的话，它的退出码就是-1。

这个时候可能就会有人问了：那既然主线程可以取消新线程，那我们的新线程能不能取消我们的主线程呢？

答案是可以的，但是我并不建议你这么做

下面我们来看一下新线程取消主线程的代码

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

using namespace std;

pthread_t g_tid;

void* Running(void* arg)
{
    char* msg = (char*)arg;
    while(true)
    {
        sleep(2);
        cout<<"I am "<<msg<<" "<<"pid 是:"<<getpid()<<"我得线程ID是"<<pthread_self()<<endl;
        pthread_cancel(g_tid);
    }
}

#define NUM 1

int main()
{
    pthread_t tid[NUM];
    fpr(int i = 0;i<NUM;i++)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer,"thread %d",i);
        pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    //拿到主线程的线程ID
    g_tid = pthread_self();
    cout<<"wait sub thread..."<<endl;
    sleep(50);
    cout<<"cancel sub thread..."<<endl;
    pthread_cancel(tid[0]);
    
    void* ret = nullptr;
    pthread_join(tid[0],&ret);
    
    cout<<"新线程退出码: "<<(long)ret<<endl;
    
    return 0;
}

下面我们调用监控脚本进行实时监控

[root@izuf65cq8kmghsipojlfvpz Thread]# while :; do ps -aL | grep -v grep;echo "######################";sleep 1;done

运行结果：

在这里插入图片描述

可以看到我们使用新线程取消主线程后，我们的主线程出现了类似于“僵尸进程”的问题。所以这也就是我为什么上面说即使新线程可以取消主线程，但是我不建议你们这么做。

注意：

线程之间地位都是对等的，因此我们既可以使用主线程去取消新线程，也可以使用新线程去取消主线程。我们使用主线程去取消新线程，只会导致新线程终止，其他线程还会正常执行。但是如果我们使用新线程去终止主线程，会导致主线程不再执行后续代码，并且出现类似于僵尸进程的问题。因此即使我们可以使用新线程去终止主线程，但是我不建议你们这么去做。

线程分离

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

那我们如果不想等待该线程并且也不想造成内存泄漏，我们应该怎么做呢？

我们可以采用线程分离，分离之后的线程不需要被join，运行完毕之后，会自动释放该线程的资源。

下面来为大家介绍一个函数——pthread_detach()

函数原型如下：

int pthread_detach(pthread_t thread);

参数：

thread：被分离线程的ID

返回值：

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

下面我们通过代码来使用一下这个函数

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

using namespace std;


void* Running(void* arg)
{
    //线程分离
    pthread_detach(pthread_self());
    char* msg = (char*)arg;
    while(true)
    {
        sleep(2);
        cout<<"I am "<<msg<<" "<<"pid 是:"<<getpid()<<"我得线程ID是"<<pthread_self()<<endl;
        break;
    }
     pthread_exit((void*)123);
}

#define NUM 1

int main()
{
    pthread_t tid[NUM];
    fpr(int i = 0;i<NUM;i++)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer,"thread %d",i);
        pthread_create(tid+i,nullptr,Running,(void*)buffer);
    }
    sleep(3);
   
    void* status = nullptr;
    int ret = 0;
    ret = pthread_join(tid[0],&status);
    
    cout<<"join 返回值: "<<ret<<" "<<"新线程退出码: "<<(long)ret<<endl;
    
    return 0;
}

运行结果：

在这里插入图片描述

我们可以看到本来是有两个线程的，然后过了两秒种之后新线程分离了，然后就只剩下一个主线程，再过了一秒主线程代码执行完毕退出了。

我们还可以看到join的返回值是22，不是0，此时证明我们的join是失败的，并且status也没有拿到线程的退出码，这是为什么呢？

这是因为一个线程被设置为分离之后，就绝对不能再进行join了，即joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

注意：

一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧需要在进程内运行，并且即使这个线程分离了，但是它如果崩溃了，还是会影响其他线程和整个进程的。

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

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

下面我们先来看一段代码

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>

using namespace std;

void* Running (void* arg)
{
    char* msg = (char*)arg;
    while(true)
    {
        sleep(1);
        printf("%s ID is 0x%x\n",msg,pthread_self());
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,Running,(void*)"new thread");
    
    while(true)
    {
        sleep(1);
        printf("main thread ID is 0x%x\n",pthread_self());
    }
        
    return 0;
}

运行结果：

在这里插入图片描述

我现在有点好奇这个线程id到底是啥？

我们查看到的线程id是pthread库的线程id，不是Linux内核中的LWP，pthread库的线程id是一个内存地址

我们通过ldd命令可以看到，我们采用的线程库实际上是一个动态库

在这里插入图片描述

我们知道要想创建线程，首先你得要有一个进程，创建进程就需要创建一堆数据结构，进程创建好了之后我们还需要使用pthread动态库，那么问题来了这个pthread动态库在磁盘上面是一个文件嘛？答案是肯定是一个文件，那既然是文件如果我们想使用它，我们就需要把它加载到内存中才行。

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

在这里插入图片描述

每个线程都要有运行时的临时数据，这也就意味着每个线程都要有自己的私有栈结构。那我们创建了这么多的用户级线程，那我们需不需要将这些线程给管理起来呢？肯定是需要的，如何管理呢？先描述再组织。因此我们还需要有描述线程的用户级控制块，这个控制块叫做struct pthread，其中包含了对应线程的各种属性，每个线程还有自己的线程局部存储，当中包含了线程被切换时的上下文数据。

那这个用户级控制块具体是怎么样的呢，我们如何快速找到一个用户级线程呢？

每个线程在共享区都有这样的一块区域对其进行描述，因此我们要找到一个用户级线程我们只需要找到该线程的用户级控制块的起始地址，就可以获取到该线程的各种信息了。

在这里插入图片描述