＜Linux＞ 线程控制

目录

一、线程资源的分配

（一）线程私有资源

（二）线程共享资源

二、原生线程库

三、线程控制接口

[（一）线程创建 - pthread_create()](#（一）线程创建 - pthread_create())

[1. 一个线程](#1. 一个线程)

[2. 一批线程](#2. 一批线程)

[（二）线程等待 - pthread_join()](#（二）线程等待 - pthread_join())

[（三）线程终止 - pthread_exit()](#（三）线程终止 - pthread_exit())

四、线程实操

五、线程控制接口补充

[（一）关闭线程 - pthread_cancel()](#（一）关闭线程 - pthread_cancel())

[（二）获取线程ID - pthread_self()](#（二）获取线程ID - pthread_self())

[（三）线程分离 - pthread_detach()](#（三）线程分离 - pthread_detach())

六、线程库的深入理解

（一）线程的ID

（二）线程独立栈

（三）线程的局部存储

---

一、线程资源的分配

（一）线程私有资源

我们已经知道一个结论：**Linux**中没有真线程，只有复用 PCB 设计思想的 TCB 结构。

因此 Linux 中的线程本质上就是 轻量级进程 （LWP ），一个进程内的多个线程看到的是同一个进程地址空间，所以所有的线程可能会共享进程的大部分资源。

但是如果多个执行流（多个线程）都使用同一份资源，如何确保自己的相对独立性呢？

• 相对独立性：线程各司其职，不至于乱成一锅粥

显然，多线程虽然共同 "生活" 在一个进程中，但也需要有自己的 "隐私" ，而这正是 线程私有资源

线程私有资源：

1. 线程 ID ：内核观点中的 LWP
2. 一组寄存器: 线程切换时，当前线程的上下文数据需要被保存
3. 线程独立栈: 线程在执行函数时，需要创建临时变量
4. 错误码 errno: 线程因错误终止时，需要告知父进程
5. 信号屏蔽字: 不同线程对于信号的屏蔽需求不同
6. 调度优先级: 线程也是要被调度的，需要根据优先级进行合理调度

其中，线程最重要 的资源是 一组寄存器（体现切换特性） 和 **独立栈（体现临时运行特性），**这两个资源共同构成了最基本的线程。

（二）线程共享资源

除了上述提到的 线程私有资源 外，多线程还共享着进程中的部分资源。

共享的定义：不需要太多的额外成本，就可以实现随时访问资源。

基于 多线程看到的是同一块进程地址空间 ，理论上 凡是在进程地址空间中出现的资源，多线程都是可以看到的， 但实际上为了确保线程调度、运行时的独立性，只能共享部分资源。

这也就是线程中的栈区称作 "独立栈" 的原因：某块栈空间属于某个线程，其他线程是可以访问的，为了确保独立性，并不会这样做。

在 进程地址空间 中，诸如 共享区、全局数据区等 这类天生自带共享属性的区域支持 多线程共享：

在 **Linux**中，多线程共享资源如下：

1. 共享区、全局数据区、字符常量区、代码区: 常规资源共享区
2. 文件描述符表 : 进行 IO操作时，无需再次打开文件
3. 每种信号的处理方式: 多线程共同构成一个整体，信号的处理动作必须统一
4. 当前工作目录: 即使是多线程，也是位于同一工作目录下
5. 用户 ID 和 组 ID: 进程属于某个组中的某个用户，多线程也是如此

其中，线程 较重要 的共享资源是：文件描述符表； 涉及 **IO**操作时，多线程 多路转接 非常实用

进程和线程关系图示：

二、原生线程库

在之前编译多线程相关代码时，我们必须带上一个选项：-lpthread，否则就无法使用多线程相关接口，带上这个选项的目的很简单：使用 pthread 原生线程库。

接下来对 原生线程库进行一个系统性的理解：

首先，在 Linux中是没有真正意义上的线程的，有的只是通过进程模拟实现的线程（LWP）

• 站在操作系统角度 ：并不会提供对线程控制的相关接口，最多提供轻量级进程操作的相关接口
• 但对于用户角度 来说：只认识线程，并不清楚轻量级进程

所以为了使用户能愉快的对线程进行操作，就需要对系统提供的轻量级进程操作相关接口进行封装：**对下封装轻量级进程操作相关接口，对上给用户提供线程控制的相关接口。**这里很好的体现了计算机界的哲学：通过添加一层软件层解决问题：

库的简单介绍

• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以**pthread_**打头的
• 要使用这些函数库，要通过引入头文**<pthread.h>**
• 链接这些线程函数库时要使用编译器命令的 **-lpthread**选项，即可正常使用多线程控制相关接口。
• 原生指的是大部分Linux系统都会默认带上该线程库，都必须预载的。

三、线程控制接口

线程是进程内部的一个执行流，作为 CPU 运行的基本单位，对于线程的合理控制与任务的执行效率息息相关，因此掌握线程基本操作（线程控制）是很有必要的。

（一）线程创建 - pthread_create()

如何创建一个线程，对于 原生线程库 来说，创建线程使用的是 pthread_create这个接口：

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);

参数：

• 参数1 pthread_t*：线程 ID，用于标识线程，其实这玩意本质上就是一个 unsigned long int 类型。 注：pthread_t*表明这是一个输出型参数，旨在创建线程后，获取新线程 ID。
• 参数2 const pthread_attr_t*：用于设置线程的属性，比如优先级、状态、私有栈大小，这个参数一般不考虑，直接传递 nullptr 使用默认设置即可。
• 参数3 void *(*start_routine) (void *)：这是一个很重要的参数，它是一个 返回值为 void* 参数也为 void* 的函数指针，线程启动时，会自动回调此函数（类似于 signal 函数中的参数2）。
• 参数4 void*：显然，这个类型与回调函数中的参数类型匹配上了，而这正是线程运行时，传递给回调函数的参数。

返回值 int：创建成功返回 0 ，失败返回 error number

1. 一个线程

我们先来创建一个线程试试水：

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

using namespace std;

void* thread_run(void *arg)
{
    while(true)
    {
        cout << "我是次线程，我正在运行..." << endl;
        sleep(1);
    }
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, nullptr);

    while(true)
    {
        cout << "我是主线程，次线程ID是：" << t << endl;
        sleep(1);
    }
    return 0;
}

错误：未定义 pthread_create 这个函数。 原因：没有指明使用 原生线程库，这是一个非常常见的问题

解决方法：编译时带上 -lpthread，指明使用 原生线程库：

现在我们已经得到了一个链接 原生线程库 的可执行程序，可以通过 ldd可执行程序 查看库的链接情况：

ldd mythread

也可以查看原生线程库的路径：/lib64/libpthread.so.0

足以证明原生线程库确确实实的存在于我们的系统中。

---

可以通过**ps -aL**查看正在运行中的线程信息：

为什么打印的次线程 ID如此长？并且与ps -aL 查出来的 **LWP**不一致？

很长是因为它本质上是一个无符号长整型，至于为什么显示不一致的问题，需要到下面才能解答。

程序运行时，主次线程的运行顺序谁先谁后？

线程的调度机制源于进程，而多进程运行时，谁先运行取决于调度器，因此主次线程运行的先后顺序不定，具体取决于调度器的调度。

2. 一批线程

那我们上点强度试试多个线程：

#define NUM 5

void* thread_run(void *name)
{
    while(true)
    {
        cout << "我是次线程 " << (char*)name << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t pt[NUM];
    for(int i = 0; i < NUM; i++)
    {
        char name[64];
        snprintf(name, sizeof(name), "thread-%d", i+1);
        pthread_create(pt+i, nullptr, thread_run, name);
    }

    while(true)
    {
        cout << "我是主线程，我正在运行..." << endl;
        sleep(1);
    }
    return 0;
}

细节：传递pthread_create 的参数1 时，可以通过 起始地址+偏移量 的方式进行传递，传递的就是 pthread_t*

预期结果：打印 thread-1、thread-2、thread-3 ...

实际结果：确实有五个次线程在运行，但打印的结果全是 thread-5:

原因：char name[64] 属于主线程中栈区之上的变量，多个线程实际指向的是同一块空间，最后一次覆盖后，所有线程都打印 thread-5 ：

这是由于多线程共享同一块区域引发的问题，解决方法就是在堆区动态匹配空间，使不同的线程读取不同的空间，这样就能确保各自信息的独立性：

#define NUM 5

void* thread_run(void *args)
{
    char *name = (char*)args;
    while(true)
    {
        cout << "我是次线程 " << name << endl;
        sleep(1);
    }
    delete name;
    return nullptr;
}

int main()
{
    pthread_t pt[NUM];
    for(int i = 0; i < NUM; i++)
    {
        char *tname = new char[64];
        snprintf(tname, 64, "thread-%d", i+1);
        pthread_create(pt+i, nullptr, thread_run, tname);
    }

    while(true)
    {
        cout << "我是主线程，我正在运行..." << endl;
        sleep(1);
    }
    return 0;
}

显然，线程每次的运行顺序取决于调度器：

在上面的程序中，主线程也是在死循环式运行，假若主线程等待 3 秒后，再 return， 会发生什么呢？

#define NUM 5

void* thread_run(void *args)
{
    char *name = (char*)args;
    while(true)
    {
        cout << "我是次线程 " << name << endl;
        sleep(1);
    }
    delete name;
    return nullptr;
}

int main()
{
    pthread_t pt[NUM];
    for(int i = 0; i < NUM; i++)
    {
        char *tname = new char[64];
        snprintf(tname, 64, "thread-%d", i+1);
        pthread_create(pt+i, nullptr, thread_run, tname);
    }
    
    sleep(3);
    return 0;
}

结果：程序运行 3 秒后，主线程退出，同时其他次线程也被强制结束了

这是因为 主线程结束了，整个进程的资源都得被释放，次线程自然也就无法继续运行了。

换句话说，次线程由主线程创建，主线程就得对他们负责，必须等待他们运行结束 ，类似于父子进程间的等待机制；如果不等待，就会引发僵尸进程问题，不过线程这里没有僵尸线程的概念，直接影响就是次线程也全部退出了。

（二）线程等待 - pthread_join()

主线程需要等待次线程，在 原生线程库 中刚好存在这样一个接口 pthread_join，用于等待次线程运行结束:

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

参数：

• 参数1pthread_t：待等待的线程 ID，本质上就是一个无符号长整型类型；这里传递是数值，并非地址。
• 参数2 void**：这是一个输出型参数，用于获取次线程的退出结果，如果不关心，可以传递 nullptr。

返回值：成功返回 0 ，失败返回 error number

函数原型很简单，使用也很简单，我们可以直接在主线程中调用并等待所有次线程运行结束：

int main()
{
    pthread_t pt[NUM];
    for(int i = 0; i < NUM; i++)
    {
        char *tname = new char[64];
        snprintf(tname, 64, "thread-%d", i+1);
        pthread_create(pt+i, nullptr, thread_run, tname);
    }

    //等待每个线程结束
    for(int i = 0; i < NUM; i++)
    {
        int ret = pthread_join(pt[i], nullptr);
        if(ret != 0)
        {
            cerr << "等待线程 " << pt[i] << "失败" << endl;
        }
    }

    return 0;
}

（三）线程终止 - pthread_exit()

线程可以被创建并运行，也可以被终止，线程终止方式有很多种，比如 等待线程回调函数执行结束 ，次线程运行五秒后就结束了，然后被主线程中的 pthread_join等待成功，次线程使命完成

void* thread_run(void *args)
{
    char *name = (char*)args;
    
    // 运行五秒结束
    int n = 5;
    while(n--)
    {
        cout << "我是次线程 " << name << endl;
        sleep(1);
    }
    delete name;
    return nullptr;
}

还有一种方法是 在次线程回调方法中调用 exit() 函数 ，但这会引发一个大问题：只要其中一个线程退出了，其他线程乃至整个进程都得跟着退出，显然这不是很合理，不推荐这样玩多线程

void* thread_run(void *args)
{
    char *name = (char*)args;
    while(true)
    {
        cout << "我是次线程 " << name << endl;
        sleep(1);
        
        //退出码设为10
        exit(10);
    }
    delete name;
    return nullptr;
}

每个线程顶多存活一秒（存活在同一秒中）就被终止了，通过 **echo $?**查询最近一次退出码，正是 10

其实 原生线程库 中有专门终止线程运行的接口 pthread_exit，专门用来细粒度地终止线程，谁调用就终止谁，不会误伤其他线程。

void pthread_exit(void *retval);

仅有一个参数 void*：用于传递线程退出时的信息。

这个参数名叫 retval，pthread_join中的参数2也叫 retval，两者有什么不可告人的秘密吗？

答案是这俩其实本质上是同一个东西，pthread_join中的 void **retval 是一个输出型参数，可以把一个 void* 指针的地址传递给 pthread_join函数，当线程调用 pthread_exit退出时，可以根据此地址对 retval赋值，从而起到将退出信息返回给主线程的作用：

为什么 pthread_join中的参数2类型为**void****？

• 因为主线程和次线程此时并不在同一个栈帧中，要想远程修改值就得传地址，类似于 int -> &int**，不过这里的 retval 类型是 void***

注意： 直接在 回调方法 中 return 退出信息，主线程中的 retval 也是可以得到信息的，因为类型都是 void*，彼此相互呼应。

所以比较完善的多线程操作应该是这样的：

void* thread_run(void *args)
{
    char *name = (char*)args;
    cout << "我是次线程 " << name << endl;

    delete name;
    pthread_exit((void*)"EXIT");
    // return (void*)"EXIT";这样也是ok的
}

int main()
{
    pthread_t pt[NUM];
    for(int i = 0; i < NUM; i++)
    {
        char *tname = new char[64];
        snprintf(tname, 64, "thread-%d", i+1);
        pthread_create(pt+i, nullptr, thread_run, tname);
    }

    //等待每个线程结束
    void *retval = nullptr;
    for(int i = 0; i < NUM; i++)
    {
        int ret = pthread_join(pt[i], &retval);
        if(ret != 0)
        {
            cerr << "等待线程 " << pt[i] << "失败" << endl;
        }
        cout << "线程 " << pt[i] << "等待成功，退出信息为：" << (const char*)retval << endl;
    }
    cout << "所以线程都已退出" << endl;

    return 0;
}

既然线程复用进程的设计思想，为什么线程退出时不需要考虑是否正常退出、错误码是什么之类的？

• 因为线程是进程的一部分，在进程中获取线程的错误信息等是无意义的，前面说过，如果一个线程因错误而被终止了，那么整个进程也就都活不了了，错误信息甄别交给父进程去完成，因此 pthread_join就没必要关注线程退出时的具体状态了；如果次线程有信息要交给主线程，可以通过 retval输出型参数获取。

四、线程实操

无论是 pthread_create 还是 pthread_join，他们的参数都有一个共同点：包含了一个 void* 类型的参数 ，这就是意味着我们可以给线程传递对象，并借此进行某种任务处理。

比如我们先创建一个包含一下信息的线程信息类，用于计算 **[0, N]**的累加和：

• 线程名字（包含 ID）
• 线程编号
• 线程创建时间
• 待计算的值 N
• 计算结果
• 状态

为了方便访问成员，权限设为 public

// 线程状态
enum class Status
{
    OK = 0,
    ERROT
};

// 线程信息类
class ThreadData
{
public:
    ThreadData(const string &name, int id, int n)
        :_name(name)
        ,_id(id)
        ,_createTime(time(nullptr))
        ,_n(n)
        ,_result(0)
        ,_status(Status::OK)
    {}
public:
    string _name;
    int _id;
    time_t _createTime;
    int _n;
    int _result;
    Status _status;
};

此时就可以编写 回调方法 中的任务实现了：

void* thread_run(void *args)
{
    ThreadData *td = static_cast<ThreadData*>(args);

    //任务处理
    for(int i = 0; i <= td->_n; i++)
        td->_result += i;

    // 如果业务处理过程中发现异常行为，可以设置 _status 为 ERROR    

    cout << "线程 " << td->_name << " ID " << td->_id 
    << " CreateTime " << td->_createTime << " done..." << endl;
    
    pthread_exit((void*)td);
    // return td;这样也是ok的
}

主线程在创建线程及等待线程时，就可以使用 **ThreadData**对象了，后续涉及任务修改时，也只需要修改类及回调方法即可，无需再更改创建及等待逻辑，有效做到了 解耦：

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

.....

int main()
{
    pthread_t pt[NUM];
    for(int i = 0; i < NUM; i++)
    {
        char tname[64];
        snprintf(tname, sizeof(tname), "thread-%d", i+1);

        // 创建对象
        ThreadData *td = new ThreadData(tname, i, 50*(10+i));
        pthread_create(pt+i, nullptr, thread_run, td);
        sleep(1); // 尽量拉开创建时间
    }

    //等待每个线程结束
    void *retval = nullptr;
    for(int i = 0; i < NUM; i++)
    {
        int ret = pthread_join(pt[i], &retval);
        if(ret != 0)
        {
            cerr << "等待线程 " << pt[i] << "失败" << endl;
        }

        ThreadData *td =  static_cast<ThreadData*>(retval);

        if(td->_status == Status::OK)
        {
            cout << "线程" << pt[i] << " 计算 [0, " << td->_n 
            << "] 的累加和结果为 " << td->_result << endl;
        }
    }
    cout << "所以线程都已退出" << endl;

    return 0;
}

程序可以正常运行，各个线程也都能正常计算出结果；这里只是简单计算累加和 ，线程还可以用于其他场景：网络传输、密集型计算、多路 **IO**等，无非就是修改线程的业务逻辑。

结论：多线程可以传递对象指针，自由进行任务处理。

五、线程控制接口补充

（一）关闭线程 - pthread_cancel()

线程可以被创建，自然也可以被关闭，可以使用 pthread_cancel关闭已经创建并运行中的线程

int pthread_cancel(pthread_t thread);

参数1 pthread_t：被关闭的线程 ID

返回值：成功返回 0 ，失败返回一个非零的 error number

这里可以直接模拟关闭线程的场景

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

using namespace std;

void *thread_run(void *args)
{
    const char *ps = static_cast<const char*>(args);

    while(true)
    {
        cout << "线程 " << ps << " 正在运行" << endl;
        sleep(1);
    }
    pthread_exit((void*)10);
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, (void*)"good morning");

    // 3秒后关闭线程
    sleep(3);
    pthread_cancel(t);

    void *retval = nullptr;
    pthread_join(t, &retval);

    // 细节：使用 int64_t 而非 uint64_t
    cout << "线程 " << t << " 已退出，退出信息为 " << (int64_t)retval << endl;
    
    return 0;
}

程序运行 3 秒后，可以看到退出信息为 -1，与我们预设的 10 不相符

原因很简单：只要是被 pthread_cancel 关闭的线程，退出信息统一为 PTHREAD_CANCELED 即 -1。 这也就解释了为什么要强转为 ingt64_t，因为无符号的 -1 非常大，不太好看

比较奇怪的实验

• 次线程可以自己关闭自己吗？答案是可以的，但貌似关闭后，主线程没有正常等待，整个进程疑似正常结束（退出码为 0）
• 次线程可以关闭主线程吗？答案是不可以，类似于 kill -9 无法终止 1 号进程

（二）获取线程ID - pthread_self()

线程 **ID**是线程的唯一标识符，可以通过 **pthread_self**获取当前线程的 ID

pthread_t pthread_self(void);

void *thread_run(void *args)
{
    cout << "当前次线程的ID为 " << pthread_self() << endl;
    return nullptr;
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, nullptr);

    pthread_join(t, nullptr);
    cout << "创建的次线程ID为 " << t << endl;
    
    return 0;
}

可以看到结果都是一样的

（三）线程分离 - pthread_detach()

父进程需要阻塞式等待子进程退出，主线程等该次线程时也是阻塞式等待，父进程可以设置为 WNOHANG，变成轮询式等待，避免自己一直处于阻塞；次线程该如何做才能避免等待时阻塞呢？

答案是 分离 Detach

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

原生线程库 提供的线程分离接口是 pthread_detach

int pthread_detach(pthread_t thread);

参数1 pthread_t：被关闭的线程 ID

返回值：成功返回 0 ，失败返回一个非零的 error number

线程分离的本质是将 **joinable**属性修改为 detach，告诉系统线程退出后资源自动释放。

注意：joinable和detach是冲突的，一个线程不能既是joinable又是detach的。

简单使用一下 线程分离:

void *thread_run(void *args)
{
    string name = static_cast<const char*>(args);

    int cnt = 5;
    while(cnt--)
    {
        cout << name << cnt << endl;
        sleep(1);
    }     
    return nullptr;
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, (void*)"thread: ");

    int cnt = 3;
    while(cnt--)
    {
        cout << "main thread: " << cnt << endl;
        sleep(1);
    }    
    return 0;
}

主线程可以不用等待次线程，两个执行流并发运行，并且不必担心次线程出现僵尸问题：

---

下面我们进行线程分离以后再进行等待，看看会发生什么：

void *thread_run(void *args)
{
    string name = static_cast<const char*>(args);

    int cnt = 5;
    while(cnt--)
    {
        cout << name << " : " << cnt << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, (void*)"thread 1");
    pthread_detach(t);

    int n = pthread_join(t, nullptr);
    if(n != 0)
    {
        cerr << "error: " << n << " : " << strerror(n) << endl;
    }
    sleep(10);
    
    return 0;
}

发现pthread_join函数立刻调用失败，返回错误码，并且执行sleep指令暂时不退出。而新线程继续正常执行。如果不在主线程中写sleep指令，则主线程会立刻退出，并连带所有线程退出：

---

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

pthread_detach(pthread_self());

void *thread_run(void *args)
{
    pthread_detach(pthread_self());
    string name = static_cast<const char*>(args);

    int cnt = 5;
    while(cnt--)
    {
        cout << name << " : " << cnt << endl;
        sleep(1);
    }     
    return nullptr;
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, (void*)"thread 1");

    int n = pthread_join(t, nullptr);
    if(n != 0)
    {
        cerr << "error: " << n << " : " << strerror(n) << endl;
    } 
    return 0;
}

发现结果与线程没分离时一致，这是因为线程被创建出来后，谁先调度是由调度器决定的。于是虽然新线程被创建出来了，但还没来的及调度执行分离函数，就被主线程先执行join函数等待了：

为了避免这个问题，在创建完新线程后，主线程等待2秒再开始执行：

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, (void*)"thread 1");
    
    sleep(2);

    int n = pthread_join(t, nullptr);
    if(n != 0)
    {
        cerr << "error: " << n << " : " << strerror(n) << endl;
    } 
    return 0;
}

结论：建议将 pthread_detach 放在待分离线程的 线程创建 语句之后，如果放在线程执行函数中，可能会因为调度优先级问题引发错误（未知结果）。

总之，线程被分离后，主线程就可以不必关心了，即不需要 join 等待，是否分离线程取决于具体的应用场景。

六、线程库的深入理解

（一）线程的ID

原生线程库 本质上也是一个文件 ，是一个存储在 /lib64目录下的动态库 ，要想使用这个库，就得在编译时带上**-lpthread**指明使用动态库

程序运行时，原生线程库 需要从 磁盘 加载至 内存 中，再通过 进程地址空间 映射至 共享区 中供线程使用：

由于用户并不会直接使用 轻量级进程 的接口，于是 需要借助第三方库进行封装 ，类似于用户可能不了解系统提供的 文件接口 ，从而使用 C语言 封装的 **FILE**库一样：

对于 原生线程库 来说，线程不止一个，因此遵循 先描述，再组织 原则，在线程库中创建 **TCB**结构（类似于 PCB），其中存储 线程 的各种信息，比如 线程独立栈 信息。

在内存中，整个 线程库 就像一个 "数组" ，其中的一块块空间聚合排布 TCB 信息，而 每个 TCB 的起始地址就表示当前线程的 ID ，地址是唯一的，因此线程 **ID**也是唯一的。

因此，我们之前打印 **pthread_t**类型的 线程 ID 时，实际打印的是地址，不过是以 十进制 显示的，可以通过函数将地址转化为使用 十六进制 显示

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

using namespace std;

string HexAdress(pthread_t t)
{
    char id[64];
    // 转换成十六进制
    snprintf(id, sizeof(id), "0x%x", t);
    return id;
}

void *thread_run(void *args)
{
    cout << "new thread | ID: " << HexAdress(pthread_self()) << endl;
    return (void*)0;
}

int main()
{
    pthread_t t;
    pthread_create(&t, nullptr, thread_run, nullptr);

    pthread_join(t, nullptr);
    cout << "main thread | ID: " << HexAdress(pthread_self()) << endl;

    return 0;
}

线程 ID 确实能转化为地址（虚拟进程地址空间上的地址）

注意： 即便是 C++11 提供的 thread 线程库，在 Linux 平台中运行时，也需要带上 -lpthread 选项，因为它本质上是对 原生线程库 的封装

（二）线程独立栈

线程 之间存在 独立栈，可以保证彼此之前执行任务时不会相互干扰，可以通过代码证明。

多个线程使用同一个入口函数，并打印其中临时变量的地址

string HexAdress(pthread_t t)
{
    char id[64];
    // 转换成十六进制
    snprintf(id, sizeof(id), "0x%x", t);
    return id;
}

void *threadRoutine(void *args)
{
    int tmp = 0;
    cout << "new thread | ID: " << HexAdress(pthread_self()) 
         << " &tmp: " << &tmp << endl;
    return (void*)0;
}

int main()
{
    pthread_t t[5];
    for(int i = 0; i < 5; i++)
    {
        pthread_create(t+i, nullptr, threadRoutine, nullptr);
        sleep(1);
    }

    for(int i = 0; i < 5; i++)
        pthread_join(t[i], nullptr);

    return 0;
}

可以看到五个线程打印 "同一个" 临时变量的地址并不相同，足以证明 线程独立栈 的存在 ：

存在这么多 栈结构 ，CPU 在运行时是如何区分的呢？

答案是 通过 栈顶指针 ebp 和 栈底指针 esp 进行切换 ，ebp 和 esp 是 **CPU**中两个非常重要的 寄存器 ，即便是程序启动，也需要借助这两个 寄存器 为 **main**函数开辟对应的 栈区。

除了移动 **esp**扩大栈区外，还可以同时移动 **ebp**和 **esp**更改当前所处栈区：

所以，多线程中 独立栈 可以通过 ebp 和 esp 轻松切换并使用

如果想要在栈区中开辟整型空间，可以使用 ebp - 4 定位对应的空间区域并使用，其他类型也是如此，原理都是 基地址 + 偏移量

注意：

1. 所有线程都要有自己独立的栈结构（独立栈），主线程中用的是进程系统栈，次线程用的是库中提供的栈。
2. 多个线程调用同一个入口函数（回调方法），其中的局部变量地址一定不一样，因为存储在线程独立栈中。

（三）线程的局部存储

线程 之间共享 全局变量 ，对 全局变量 进行操作时，会影响其他线程：

int g_val =  100;

string HexAdress(pthread_t t)
{
    char id[64];
    // 转换成十六进制
    snprintf(id, sizeof(id), "0x%x", t);
    return id;
}

void *threadRoutine(void *args)
{
    int tmp = 0;

    cout << "new thread | ID: " << HexAdress(pthread_self()) 
    << " g_val: " << ++g_val << ", &g_val: " << &g_val << endl;

    return (void*)0;
}

int main()
{
    pthread_t t[5];
    for(int i = 0; i < 5; i++)
    {
        pthread_create(t+i, nullptr, threadRoutine, nullptr);
        sleep(1);
    }

    for(int i = 0; i < 5; i++)
        pthread_join(t[i], nullptr);

    return 0;
}

在5个线程的累加下，g_val 最终变成了105

如何让全局变量私有化呢？即每个线程看到的全局变量不同

可以给全局变量加 __thread 修饰，修饰之后，全局变量不再存储至全局数据区，而且存储至线程的 局部存储区中。

__thread int g_val = 100;

结果：修饰之后，每个线程确实看到了不同的 "全局变量"。此时的 "全局变量" 的地址也变大了：

"全局变量" 地址变大是因为此时它不再存储在 全局数据区 中，而且存储在线程的 局部存储区 中，线程的局部存储区位于 共享区，并且 共享区 的地址天然大于 全局数据区。

结论： 局部存储区位于共享区中，可以通过 __thread 修饰来改变变量的存储位置。