Linux多线程详解

- 一、Linux多线程概念
- - 1.1 什么是线程
  - 1.2 进程和线程
  - 1.3 进程的多个线程共享
  - 1.4 进程和线程的关系
- 二、Linux线程控制
- - 2.1 POSIX线程库
  - 2.2 线程创建
  - 2.3 获取线程ID pthread_self
  - 2.4 线程等待pthread_join
  - 2.5 线程终止
  - 2.6 线程栈 && pthread_t
  - 2.7 线程的局部存储
  - 2.8 分离线程pthread_detach
- 三、线程的优缺点
- - 3.1 线程的优点
  - 3.2 线程的缺点
- 四、线程异常
- 五、线程用途

一、Linux多线程概念

1.1 什么是线程

在一个程序里的一个执行路线就叫做线程（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函数创建出来的子进程与其父进程共享地址空间，例如在下面的代码中，父进程使用vfork函数创建子进程，子进程将全局变量g_val由100改为了200，父进程休眠3秒后再读取到全局变量g_val的值。

#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){
		//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下学习线程实际上就是学习在用户层模拟实现的这一套接口，而并非操作系统的接口。

1.2 进程和线程

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

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

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

1.3 进程的多个线程共享

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

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

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

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

1.4 进程和线程的关系

进程和线程的关系如下图：
在这里插入图片描述
在此之前我们接触到的都是具有一个线程执行流的进程，即单线程进程。

二、Linux线程控制

2.1 POSIX线程库

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

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

错误检查：

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

2.2 线程创建

创建线程的函数叫做pthread_create

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：传给线程例程的参数。

返回值说明：

线程创建成功返回0，失败返回错误码。

让主线程创建一个新线程

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

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

下面我们让主线程调用pthread_create函数创建一个新线程，此后新线程就会跑去执行自己的新例程，而主线程则继续执行后续代码。

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void* startRoutine(void* args)
{
    while (true)
    {
        cout << "线程正在运行..." << endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void*)"thread1");
    cout << "new thread id : " << tid << endl;//线程ID
    while (true)
    {
        cout << "main thread 正在运行..." << endl;
        sleep(1);
    }
    return 0;
}

运行代码后可以看到，新线程每隔一秒执行一次打印操作，而主线程每隔两秒执行一次打印操作。
在这里插入图片描述
可以看到，主线程创建新线程后，二者一同运行着，且我们的新线程的ID很大。至于为什么这么大后续谈。

2.3 获取线程ID pthread_self

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

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

pthread_self函数的函数原型如下：

pthread_t pthread_self(void);

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

例如，下面的代码，我们让主线程和新线程都通过pthread_self函数来获取自身的ID，并统一用16进制的方式打印。

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x\n", name, tid);
}
void* startRoutine(void* args)
{
    const char* name = static_cast<const char*>(args);
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void*)"thread1");
    while (true)
    {
        printTid("main thread", pthread_self());
        sleep(1);
    }
    return 0;
}

在这里插入图片描述

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

2.4 线程等待pthread_join

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

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

参数说明：

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

返回值说明：

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

示例：

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

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x\n", name, tid);
}
void* startRoutine(void* args)
{
    const char* name = static_cast<const char*>(args);
    int cnt = 500;
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
        if (!(cnt--))   break;
    }
    cout << "线程退出啦...." << endl;
    return nullptr;
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void*)"thread1");
    sleep(1000);
    pthread_join(tid, nullptr);
    return 0;
}

在这里插入图片描述
如上我们发现，运行后，线程如约运行，并用ps axj命令查看此进程信息，当我们发送19号暂停此线程后，会发现我整个线程都跟着暂停了，当我发送18号信号，再次运行此线程时，又会发现线程又同时运行了，因为它们是在一个进程的。
在这里插入图片描述
下面更改代码，让新线程创建5s后退出，随后再过几秒后被thread_join等待，当主进程开始打印消息时，说明新线程join等待完成：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x\n", name, tid);
}
void* startRoutine(void* args)
{
    const char* name = static_cast<const char*>(args);
    int cnt = 5;
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
        if (!(cnt--))   break;
    }
    cout << "线程退出啦...." << endl;
    return nullptr;
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void*)"thread1");
    sleep(10);
    pthread_join(tid, nullptr);
    cout << "main thread join success" << endl;
    sleep(10);
    while (true)
    {
        printTid("main thread", pthread_self());
        sleep(1);
    }
    return 0;
}

我们使用如下监控脚本辅助我们观察现象：

while :; do ps -aL | head -1 && ps -aL | grep mytest; sleep 1; done

在这里插入图片描述
会发现当创建线程后，线程1正在运行，5s后新线程退出了，我们的监控脚本观察到线程由两个变成了一个，但是正常情况下预期应该是两个线程，随后线程等待成功，这里还是只能看到一个线程。不是说好退出后应该看到的是两个线程吗，事实上一个线程退出后我们并没有看到预期结果。原因是ps命令在查的时候退出的线程是不给你显示的，所以你只能看到一个线程。但是现在不能证明当前的新线程在退出没有被join的时候就没有内存泄漏。

所以线程退出的时候，一般必须要进行join，如果不进行join，就会造成类似于进程那样的内存泄漏问题。

来看下线程异常的问题：

如下的野指针问题：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x\n", name, tid);
}
void *startRoutine(void *args)
{
    const char *name = static_cast<const char *>(args);
    int cnt = 5;
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
        if (!(cnt--))
        {
            int *p = nullptr;
            *p = 100; // 野指针问题
        }
    }
    cout << "线程退出啦...." << endl;
    return nullptr;
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void *)"thread1");
    sleep(10);
    pthread_join(tid, nullptr);
    cout << "main thread join success" << endl;
    sleep(10);
    while (true)
    {
        printTid("main thread", pthread_self());
        sleep(1);
    }
    return 0;
}

同样是使用如下的监控脚本辅助我们观察现象：

while :; do ps -aL | head -1 && ps -aL | grep mytest; sleep 1; done

在这里插入图片描述
此时会发现：待线程出现野指针问题时，左边会显示段错误，而右边监控脚本中的线程直接就没了。此时就说明当线程异常了，那么整个进程整体异常退出，线程异常 == 进程异常。所以线程会影响其它线程的运行 —— 线程的健壮性（鲁棒性）较低。

再来看看pthread_join等待函数的函数原型：

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

问：如何理解第二个参数retval？

参数retval是线程退出时的退出码，这是一个二级指针，一个输出型参数。刚刚我们的代码中，以及涉及到了线程退出的方式（从线程函数return）。退出的类型是void*。
ptherad_join的第二个参数retval的作用就是一个输出型参数，获取新线程退出时的退出码。我们先前讲过进程退出时，分为三种情况：

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

在线程退出时，代码跑完，结果不正确和结果正确都可以得到退出码，但是线程异常时并不会出现退出码。那么为什么异常时主线程没有获取新线程退出时的信号呢？

因为线程出异常就不再是线程的问题，而是进程的问题，应该让父进程获取退出码，知道它什么原因退出的。因此线程终止时，只需考虑正常终止.

2.5 线程终止

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

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

方法一（从线程函数return）

此法我们在上面已经见过，就不做演示。

方法二（pthread_exit）

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

#include <pthread.h>
void pthread_exit(void *retval);

参数说明：

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

注意：

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

例如，在下面代码中，我们使用pthread_exit函数终止线程，并将线程的退出码设置为1111：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x\n", name, tid);
}
void *startRoutine(void *args)
{
    const char *name = static_cast<const char *>(args);
    int cnt = 5;
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
        if (!(cnt--))
        {
            break;
        }
    }
    cout << "线程退出啦...." << endl;
    //1、线程退出方式1: 从线程函数直接return
        /*return (void *)111;*/
    //2、线程退出方式2: pthread_exit
    pthread_exit((void*)1111);
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void *)"thread1");
    (void)n;
    void *ret = nullptr;
    pthread_join(tid, &ret);
    cout << "main thread join success, *ret: " << (long long)ret << endl;
    sleep(10);
    while (true)
    {
        printTid("main thread", pthread_self());
        sleep(1);
    }
    return 0;
}

在这里插入图片描述
这段代码我们也能看出使用pthread_exit只能退出当前子线程，不会影响其它线程。

问：为何终止线程要用pthread_exit，exit不行吗？

看如下的代码：

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;
__thread int global_value = 100;
void *startRoutine(void *args)
{
    while (true)
    {
        cout << "thread" << pthread_self() << " global_value: " << global_value
             << " Inc: " << global_value++ << "lwp: " << syscall(SYS_gettid) << endl;
        sleep(1);
        break;
    }
    exit(1);
}
int main()
{
    pthread_t td1;
    pthread_t td2;
    pthread_t td3;
    pthread_create(&td1, nullptr, startRoutine, (void *)"thread 1");
    pthread_create(&td2, nullptr, startRoutine, (void *)"thread 2");
    pthread_create(&td3, nullptr, startRoutine, (void *)"thread 3");
 
    int n = pthread_join(td1, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(td2, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(td3, nullptr);
    cout << n << ":" << strerror(n) << endl;
    return 0;
}

在这里插入图片描述
总结：

exit是退出进程，任何一个线程调用exit，都表示整个进程退出。无论哪个子线程调用整个程序都将结束。而pthread_exit的作用是只退出当前子线程。即使你放在主线程，它也会只退出主线程，其它线程有运行的仍会继续运行。

方法三（pthread_cancel）

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

#include <pthread.h>
int pthread_cancel(pthread_t thread);

参数说明：

thread：被取消线程的ID。

返回值说明：

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

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

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x\n", name, tid);
}
void *startRoutine(void *args)
{
    const char *name = static_cast<const char *>(args);
    int cnt = 5;
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
        if (!(cnt--))
        {
            // break;
        }
    }
}
int main()
{
    pthread_t td;
    int n = pthread_create(&td, nullptr, startRoutine, (void *)"thread1");
    (void)n;
    sleep(3);//代表main thread对应的工作
    cout << "new thread been canceled" << endl;
    pthread_cancel(td);
    void *ret = nullptr;
    pthread_join(td, &ret);
    cout << "main thread join success, *ret: " << (long long)ret << endl;
    sleep(10);
    while (true)
    {
        printTid("main thread", pthread_self());
        sleep(1);
    }
    return 0;
}

在这里插入图片描述

为什么退出的结果是-1呢？

线程和进程一样，用的都是PCB，退出时都有自己的退出码，调用return或exit就是自己修改PCB中的退出结果（退出码），取消这个线程时，是OS取消的，就直接向退出码中写-1。
这里的-1就是pthread库里头给我们提供的宏（PTHREAD_CANCELED）

上述我们做的测试是让main thread主线程去取消新线程new thread，不推荐反过来。这里就不做测试了。

2.6 线程栈 && pthread_t

pthread_t实际上就是地址。

线程是一个独立的执行流
线程一定会在自己的运行过程中，产生临时数据（调用函数，定义局部变量等）
线程一定需要有自己的独立的栈结构

前面学习到，线程共享进程地址空间的内容，堆区也是的，堆区是动态申请的，线程内可以自己将其保持着，如果需要，这块空间是可以被其它线程保持可见性的，全局数据区也是如此：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
int global_value = 100;
static void printTid(const char *name, const pthread_t &tid)
{
    printf("%s 正在运行, thread id: 0x%x, global_value: %d\n", name, tid, global_value);
}
void *startRoutine(void *args)
{
    const char *name = static_cast<const char *>(args);
    int cnt = 5;
    while (true)
    {
        printTid(name, pthread_self());
        sleep(1);
        if (!(cnt--))
        {
            global_value = 200;
        }
    }
    cout << "线程退出啦..." << endl;
    int* p = new int(10);
    return (void*)p;
}
int main()
{
    pthread_t tid;
    int n = pthread_create(&tid, nullptr, startRoutine, (void *)"thread1");
    (void)n;
    while (true)
    {
        printTid("main thread", pthread_self());
        sleep(1);
    }
        void *ret = nullptr;
    pthread_join(tid, &ret);
    cout << "main thread join success, *ret: " << *((int*)ret) << endl;
    delete (int*)ret;
    return 0;
}

如上我们设置全局变量为100，新线程和主线程在打印5次后，新线程对全局变量做修改，随后观察到的现象应该是全局变量由100变成200，主线程和新线程都应该是这个现象：
在这里插入图片描述

理解了数据区和堆区的划分，现在来看线程的独立栈结构。

我们使用的线程库，是用户级线程库：pthread。是因为Linux没有真线程，没有办法提供真的线程调用接口，只能提供创建子进程、共享地址空间的调用接口。但是进程的代码、数据……怎么划分这些都是由线程库自己维护的。注意：此pthread库是动态库。

当我们需要用到此动态库时，要把它加载到内存，随后映射进对应的进程地址空间。

因为要把此动态库加载到物理内存，所以我的磁盘中有如上（libpthread.so动态库 & mytest.exe可执行程序）。我们在运行时，首先要把此可执行程序mytest.exe加载到内存，此程序内部的代码中一定有pthread_create，pthread_join这些从libpthread.so动态库里调来的函数，所以此时OS把该动态库加载到内存。随后把此动态库经过页表映射到进程地址空间的共享区当中，我们的task_truct通过虚拟地址访问代码区然后跳转至共享区内，执行相关的创建线程等工作，执行后再返回至代码区。

所以最终都是在地址空间中的共享区内完成对应的线程创建等操作的。
所以在我们的代码中一定充斥着三大部分（你的，库的，系统的）。所有的代码都是在进程的地址空间当中进行执行的。

问：pthread_t究竟是什么呢？

既然我们已经知道此动态库会被加载到共享区，那么我们把此共享区的libpthread.so动态库放大来讨论。线程的全部实现，并没有全部体现在OS内，而是OS提供执行流，具体的线程结构由库来进行管理。如下：

操作系统只提供轻量级进程，对于用户他不管，只要线程。所以在用户和OS之间设计了libpthread.so库，用于创建线程，等待线程……操作。用户创建一个线程，库做了转换，让你在系统帮你创建一个轻量级进程，用户终止一个线程，库帮你终止一个轻量级进程，用户等待一个线程，库帮你转换成等待一个轻量级进程，并且把结果返回。此库起到的就是承上启下的作用。
在这里插入图片描述

库可以创建多个线程，需要对这些线程进行管理（先描述，再组织）。库里头通过类似struct thread_info的结构体（注意里头是有私有栈的）来进行管理：

struct thread_info
{
    pthread_t tid;
    void *stack; // 私有栈
    ...
}

当你在用户层每创建一个线程时，在库里头就会创建一个线程控制块struct thread_info（描述线程的属性）。给创建线程的用户返回的是该结构体的起始虚拟地址。所以我们的pthread_t实际上就是用户级线程的控制结构体的起始地址！！！。
在这里插入图片描述

既然每一个线程都有struct thread_info结构体，而此结构体内部又有私有栈，所以结论如下：

主线程的独立栈结构，用的就是地址空间中的栈区
新线程用的栈结构，用的是库中提供的栈结构

2.7 线程的局部存储

我们的线程除了保存临时数据时可以有自己的线程栈，我们的pthread给我们了一种能力，如果定义了一个全局变量（默认所有线程共享），但是你想让每个线程各自私有，那么我们就可以使用线程局部存储。

如下我们创建了3个线程，创建一个全局变量，默认情况下此全局变量所有线程共享，现在我们来打印此全局变量以及地址来观察现象：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
int global_value = 100;
void *startRoutine(void *args)
{
    while (true)
    {
        cout << "thread" << pthread_self() << " global_value: " << global_value
             << " &global_value: " << &global_value << " Inc: " << global_value++ << endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_create(&tid1, nullptr, startRoutine, (void *)"thread 1");
    pthread_create(&tid2, nullptr, startRoutine, (void *)"thread 2");
    pthread_create(&tid3, nullptr, startRoutine, (void *)"thread 3");
    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);
    pthread_join(tid3, nullptr);
    return 0;
}

正常情况下，我们观察到着三个线程打印的全局变量地址应该都是一样的，且打印的变量是在累加的，这是正常的，因为共享全局变量，我的修改别人也能拿到。
在这里插入图片描述

为了让此全局变量独属于各个线程所私有，我们只需要给全局变量前假设__thread即可，加了这个__thread就会默认把这个global_value再拷一份给每一个进程。

__thread int global_value = 100;

代码如下：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
__thread int global_value = 100;
void *startRoutine(void *args)
{
    while (true)
    {
        cout << "thread" << pthread_self() << " global_value: " << global_value
             << " &global_value: " << &global_value << " Inc: " << global_value++ << endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_create(&tid1, nullptr, startRoutine, (void *)"thread 1");
    pthread_create(&tid2, nullptr, startRoutine, (void *)"thread 2");
    pthread_create(&tid3, nullptr, startRoutine, (void *)"thread 3");
    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);
    pthread_join(tid3, nullptr);
    return 0;
}

如下可以看到，创建的3个线程，每个线程的全局变量的地址都是不一样的，修改变量时，互相之间没有影响，各自独立。
在这里插入图片描述

线程是有自己的轻量级进程lwp的，如果我们想要拿到此lwp，我们可以调用gettid函数获得

#include <sys/types.h>
pid_t gettid(void);

但是此函数不能直接使用，必须得调用syscall函数，在里头调用SYS_gettid才能拿到lwp。

#include <unistd.h>
#include <sys/syscall.h>   /* For SYS_xxx definitions */
int syscall(int number, ...);

代码如下：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;
__thread int global_value = 100;
void *startRoutine(void *args)
{
    while (true)
    {
        cout << "lwp: " << syscall(SYS_gettid) << endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_create(&tid1, nullptr, startRoutine, (void *)"thread 1");
    pthread_create(&tid2, nullptr, startRoutine, (void *)"thread 2");
    pthread_create(&tid3, nullptr, startRoutine, (void *)"thread 3");
    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);
    pthread_join(tid3, nullptr);
    return 0;
}

我们使用如下的监控脚本辅助我们观察现象：

ps -aL | head -1 && ps -aL | grep mytest

在这里插入图片描述

2.8 分离线程pthread_detach

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

分离线程的函数叫做pthread_detach，pthread_detach函数的函数原型如下：

#include <pthread.h>
int pthread_detach(pthread_t thread);

参数说明：

thread：被分离线程的ID。

返回值说明：

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

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

为什么我sleep(1)后才符合我们的预期呢？（一个线程不能既是joinable又是分离的）。有sleep之后join就会失败，没有sleep，join就会成功，那么哪个才是正确的呢？

我们更倾向于让主线程去分离其它线程：

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;
__thread int global_value = 100;
void *startRoutine(void *args)
{
    cout << "线程分离..." << endl;
    while (true)
    {
        cout << "thread" << pthread_self() << " global_value: " << global_value
             << " Inc: " << global_value++ << "lwp: " << syscall(SYS_gettid) << endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_create(&tid1, nullptr, startRoutine, (void *)"thread 1");
    pthread_create(&tid2, nullptr, startRoutine, (void *)"thread 2");
    pthread_create(&tid3, nullptr, startRoutine, (void *)"thread 3");
 
 //等待一秒为了防止，子线程还没分离，主线程就开始等待了。
    sleep(1);
    pthread_detach(tid1);
    pthread_detach(tid2);
    pthread_detach(tid3);
 
 //验证不能既分离又join等待
    int n = pthread_join(tid1, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid2, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid3, nullptr);
    cout << n << ":" << strerror(n) << endl;
    return 0;
}

在这里插入图片描述

总结分离线程：

线程分离了，意味着，不在关心这个线程的死活。所以这也相当于线程退出的第4种方式，延后退出。
立即分离或者延后分离都可以，但是要保证线程活着。
新线程分离，但是主线程先退出（进程退出），所有线程就都退了。
一般分离线程，对应的主线程不退出（常驻内存的进程）

三、线程的优缺点

3.1 线程的优点

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

概念说明：

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

3.2 线程的缺点

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