【Linux】多线程——线程概念|进程VS线程|线程控制

> 作者：დ旧言~
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：理解【Linux】多线程——线程概念|进程VS线程|线程控制

> 毒鸡汤：有些事情，总是不明白，所以我不会坚持。早安!

> 专栏选自：Linux初阶

> 望小伙伴们点赞👍收藏✨加关注哟💕💕

🌟前言

早期我们的计算机还只能单个进程运行，这样的话每个进程就只能独立存在，不可以进行每个进程交互，在这个基础上我们的先人（大佬）看看能不能多个进程同时运行，也就有了现在的多进程，那对比单个进程，多进程有什么优势呢？值不值得我们学习呢？咱们带上这两个问题来康康Linux下的多线程。

⭐主体

学习【Linux】多线程——线程概念|进程VS线程|线程控制咱们按照下面的图解：

🌙 地址空间和页表

地址空间是进程能看到的资源窗口：一个进程能看到代码区、共享区、内核区、堆栈区，大部分的资源都是在地址空间上看到的。

页表决定进程真正拥有资源的情况：当前进程认为自己有了4GB，可是实际上用了多少由页表决定最终能用多少物理资源。

合理的对地址空间与页表进行资源划分，我们就可以对一个进程所有的资源进行分类：通过地址空间分为栈区、堆区…通过页表映射到不同的物理内存。

💫 页表的映射

在32位平台下一共有2³²个地址，也就意味着有2³²个地址需要被映射：

地址空间一共有2³²个地址，每个地址单位都是1字节，而页表也得有2³²个条目，每个地址都得经过页表映射，都是页表的每个条目（包括物理地址，包括是否命中，包括RWX权限，包括U/K权限，一个条目，假设为6个字节，样例数据），所以，光保存页表所需空间为24GB（4GB约为40亿字节）。

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

每个应表项中存储一个物理地址和一个虚拟地址就需要8个字节，考虑到还需要包含权限相关的各种信息，这里每一个表项就按10个字节计算：

这里一共有2³²个表项，也就意味着存储这张页表需要用2³² * 10个字节，也就是40GB
而在32位平台下我们的内存可能一共就只有4GB，也就是说我们根本无法存储这样的一张页表

💫 二级页表

虚拟地址在被转化的过程中，不是直接转化的！而是拆分成了10 + 10 + 12
以32位平台为例，其页表的映射过程如下：

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

相关说明：

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

这实际上就是所谓的二级页表，其中页目录项是一级页表，页表项是二级页表

每一个表项还是按10字节计算，页目录和页表的表项都是2¹º个，因此一个表的大小就是2¹º也就是10个字节，也就是10KB
页目录有2¹º个表项也就意味着页表有2¹º个，也就是说一级页表有1张，二级页表有2¹º张，总共算下来大概就是10MB，内存消耗并不高，因此Linux中实际就是这样映射的。

**注意：**Linux中，32位平台用的是二级页表，64位平台用的是多级页表

🌙 进程基础概念

💫 线程是什么

概念：

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

进程对应的模型：进程的创建实际上伴随着其进程控制块（task_struct）、进程地址空间（mm_struct）以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的：

进程=内核数据结构+代码和数据,每个进程都有自己独立的进程地址空间和独立的页表，也就意味着所有进程在运行时本身就具有独立性，我们在创建“进程”时，只创建PCB，并要求创建出来的PCB不在独立创建，与父进程同享PCB，那么创建的结果就是下面这样的：

因为我们可以通过虚拟地址空间+页表的方式对进程进行资源划分，单个“进程”执行力度一定要比之前的进程要细。上图中每个线程都是当前进程里的一个执行流，线程在进程内部运行，线程在进程的地址空间内运行，拥有该进程的一部分资源。

💫 如何理解线程

每个进程都有自己独立的进程地址空间和独立的页表，也就意味着所有进程在运行时本身就具有独立性。

在创建进程时，它要创建PCB，页表，建立代码和数据的映射关系…
所以创建一个进程的成本非常高。

如果创建"进程"时，只创建task_struct，并要求创建出来的task_struct和父task_struct共享进程地址空间和页表。

现在创建的进程不再给你独立分配地址空间和页表，而是都指向同一块地址空间，共享同一块页表。
所以这四个task_struct看到的资源都是一样的，后续可以通过某种方式把代码区拆分成4块，让这四个task_struct执行不同的代码区域。
上述的区域(数据区，堆区，栈区)也是类似处理方式。
换言之，后续创建的3个task_struct都各自有自己的一小份代码和数据，把这样的一份task_struct称之为线程。
其中每一个线程都是当前进程里面的一个执行流，也就是常说的"线程是进程内部的一个执行分支"。

线程在进程内部运行，本质就是线程在进程地址空间内运行，也就是说曾经这个进程申请的所有资源，几乎都是被所有线程共享的。

线程比进程更细，是因为其执行的代码和数据更小了。
线程的调度成本更低了，是因为它将来在调度的时候，核心数据结构(地址空间和页表)均不用切换了。

上述线程仅仅是在Linux下的实现，不同平台对线程管理可能不一样。

如Windows有真正的有关多线程的数据结构。
而Linux并没有真正的对线程创建对应的数据结构。
Linux的线程是用进程PCB模拟的。
所以Linux并不能直接提供线程相关的接口，只能提供轻量级进程的接口。

💦在用户层实现了一套用户层多线程方案，以库的方式提供给用户进行使用。

💦pthread线程库。

CPU视角下，Linux下，PCB <= 其他OS内的PCB。

Linux下的进程，统一称之为：轻量级进程。

💫 线程优点

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

💫 线程缺点

性能损失：

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

健壮性降低：编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
缺乏访问控制：进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
编程难度提高：编写与调试一个多线程程序比单线程程序困难得多。

💫 线程异常

线程一旦异常，会导致整个进程整体退出：

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

💫 线程用途

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

🌙 进程VS线程

💫 进程和线程

进程是资源分配的基本单位
线程是调度的基本单位

线程ID
一组寄存器
栈
errno
信号屏蔽字
调度优先级

为什么线程切换的成本更低

地址空间和页表不需要切换。
CPU内部是有L1~L3 cache，如果进程切换，cache就立即失效，新进程过来，只能重新缓存。

💫 进程和线程的资源共享

进程的多个线程共享同一地址空间，因此Text Segment、Data Segment都是共享的：

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

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

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

补充说明：

__thread int g_val = 100; // 修饰全局变量，让每一个线程各自拥有一个全局的变量  --  线程的局部存储

💫 进程和线程的关系

💫 关于进程线程的问题

如何看待之前学习的单进程？

具有一个线程执行流的进程。

引入线程后，如何重新理解之前的进程？

红色方框框起来的内容，将这个整体称作进程
曾经理解的进程 = 内核数据结构 + 进程对应的代码和数据
现在的进程，从内核角度看：承担分配系统资源的基本实体

一个进程内部一定存在多个执行流，那么这些执行流在CPU角度有区别吗？

没有任何区别，CPU不关心当前是进程还是线程这样的概念，只关心PCB，CPU调度的时候照样以task_struct为单位来进行调度。

只是这里task_struct背后的代码和页表只是曾经的代码和页表的一小部分而已。
所以CPU执行的只是一小块代码和数据，但并不妨碍CPU执行其它执行流。
所以就可以把原本串行的所有代码转变成并发或并行的，让这些代码在同一时间点得以推进。

总结如下：

以前CPU看到的所有的task_struct都是一个进程，现在CPU看到的所有的task_struct都是一个执行流(线程)

🌙线程控制

💫 POSIX线程库

使用：

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

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

我们说过，在Linux没有真正意义上的线程，无法直接提供创建线程的系统接口，只能给我们提供创建轻量级进程的接口。但是在用户的角度上，当我们想创建一个线程时会使用thread_create这样的接口，而不是我们上面所使用vfork函数，用户不能直接访问OS，所以OS在用户和系统调用之间提供了编写好的用户级线程库，这个库一般称为pthread库。任何Linux操作系统都必须默认携带这个库，这个库称为原生线程库。
原生的线程库本质上就是对轻量级进程的系统调用（clone）进行了封装pthread_create，使用户层模拟实现了一套线程相关的接口。
我们认为的线程实际在OS内部会被转化成我们所谓的轻量级进程。

错误检查:

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

💫 创建线程——pthread_create

pthread_create讲解：

pthread_create:创建线程的函数

#include <pthread.h>

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

thread:获取线程的ID，该参数是一个输出型参数
attr:用于设置创建线程的属性，传入nullptr表示默认，这个属性基本不管
start_routine:函数地址，表示线程启动后要执行的函数
arg:传给线程例程的参数
返回值：成功返回0，失败返回错误码

举个栗子：

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
using namespace std;
void * thread_routine(void *args)
{
    const char*name = (const char*)args;
    while(true)
    {
        cout<<"这是新线程，我正在运行!"<<name<<endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    int n = pthread_create(&tid,nullptr,thread_routine,(void*)"thread one");
    assert(0==n);
    (void)n;

    while(true)
    {
        cout<<"这是主线程，我真正运行！"<<endl;
        sleep(1);
    }

    return 0;
}

这里编译运行需要注意：这个接口是库给我们提供的，使用的接口如果不是语言上的接口或者操作系统上的接口，如果是库提供的，那在编译时是不通过的，我们需要找到这个库。-L：找到库在哪里，-I：找到头文件在哪里，但是这个库已经在系统里安装好了，除了告诉库和头文件在哪之外，还需要知道链接哪一个库！

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

而使用ps -aL指令，就可以显示当前的轻量级进程了：

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

注意：主线程的PID和LWP是一样的。不一样的就是新线程。所以CPU调度的时候，是以LWP为标识符表示特定一个执行流。
线程一旦被创建，几乎所有的资源都是被所有线程共享的。所以线程之间想交互数据就容易了，直接就能看到。

线程也一定要有自己私有的资源：

线程被调度就要有独立的PCB属性私有。
线程切换时正在运行，需要进行上下文保存，要有私有的上下文结构。
每个进程都要独立的运行，每个线程都要有自己独立的栈结构。

主线程创建一批新线程：

我们让主线程一次性创建十个新线程，并让创建的每一个新线程都去执行start_routine函数，也就是说start_routine函数会被重复进入，即该函数是会被重入的：

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

class ThreadData
{
public:
    pthread_t tid;
    char namebuffer[64];
    
};

//创建一批新线程
void* start_routine(void* args)
{
    sleep(1);
    ThreadData *td = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        cout<<"new thread create success,name: "<<td->namebuffer<<" cnt : "<<cnt--<<endl;
        sleep(1);
    }
    delete td;
    return nullptr;
}
int main()
{
    vector<ThreadData*> threads;
#define NUM 10
    for(int i = 0;i<NUM;i++)
    {
        ThreadData *td = new ThreadData();
        snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i+1);
        pthread_create(&td->tid,nullptr,start_routine,td);
        threads.push_back(td);
       // sleep(1);
    }

    for(auto&iter:threads)
    {
        cout<<"create thread: "<<iter->namebuffer<<" : "<<iter->tid<<" sucess" <<endl;
    }
    while(true)
    {
        cout<<"new thread create success,name: main thread"<<endl;
        sleep(1);
    }
    return 0;
}

并且start_routine是可重入函数，没有产生二义性，没有因为一个线程去影响另一个线程。并且在函数内定义的变量都是局部变量具有临时性，在多线程情况下也没有问题。这也说明了每一个线程都有自己独立的栈结构

获取线程ID——pthread_self：

获取线程ID：1.创建线程时通过输出型参数获得；2.通过pthread_self接口函数获得

#include <pthread.h>
pthread_t pthread_self(void);

我们可以打印出主线程打印出新线程的ID，新线程打印自己的ID，看是否相同：结果是相同的

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

string changeId(const pthread_t &thread_id)
{
    char tid[128];
    snprintf(tid,sizeof(tid),"0x%x",thread_id);
    return tid;
}
void* start_routine(void*args)
{
    std::string threadname = static_cast<const char*>(args);
    while(true)
    {
        cout<<threadname<<" running ... "<<changeId(pthread_self())<<endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,start_routine,(void*)"thread 1");
    
    cout<<"main thread running ... new thread id: "<<changeId(tid)<<endl;
    pthread_join(tid,nullptr);
    return 0;
}

💫 线程等待——pthread_join

概念：

一个线程创建出来，那就要如同进程一样，也是需要被等待的。如果线程不等待，对应的PCB没被释放，也会造成类似僵尸进程的问题：内存泄漏。所以线程也要被等待：

获取新线程的退出信息
回收新线程对应的PCB等内核资源，防止内存泄漏。

可以不关心线程的退出信息。

pthread_join:等待线程的函数

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

参数：thread:被等待线程的ID，retval:线程退出时的退出码信息
void** retval:输出型参数，主要用来获取线程函数结束时返回的退出结果。之所以是void**,是因为如果想作为输出型结果返回，因为线程函数的返回结果是void*,而要把结果带出去就必须是void**,
返回值：线程等待成功返回0，失败返回错误码

举个栗子：

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

class ThreadData
{
public:
    int number;
    pthread_t tid;
    char namebuffer[64];
    
};
class ThreadReturn
{
public:
    int exit_code;
    int exit_result;
};
//创建一批新线程
void* start_routine(void* args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        cout<<"cnt:"<<cnt<<"&cnt:"<<&cnt<<endl;
        cnt--;
        sleep(1);
    }
   ThreadReturn* tr = new ThreadReturn();
   tr->exit_code = 1;//线程退出码
   tr->exit_result = 100;//线程退出结果
   return (void*)tr;
   //return (void*)td->number;//waring void*ret = (void*)td->number;8字节、4字节
}
int main()
{
    vector<ThreadData*> threads;
#define NUM 10
    for(int i = 0;i<NUM;i++)
    {
        ThreadData *td = new ThreadData();
        td->number = i+1;
        snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i+1);
        pthread_create(&td->tid,nullptr,start_routine,td);
        threads.push_back(td);
    }
    for(auto&iter:threads)
    {
        cout<<"create thread: "<<iter->namebuffer<<" : "<<iter->tid<<" sucess" <<endl;
    }
    for(auto&iter:threads)
    {
        ThreadReturn*ret = nullptr;
        int n = pthread_join(iter->tid,(void**)&ret);
        assert(n==0);
        cout<<"join : "<<iter->namebuffer<<" success,exit_code: "<<ret->exit_code<<",exit_result: "<<ret->exit_result<<endl;
        delete iter;
    }
    cout<<"main thread quit"<<endl;
    return 0;
}

总结：

没有看到线程退出时对应的退出信号：这是因为线程出异常收到信号，整个进程都会退出，所以退出信号要由进程来关心，所以pthread_join默认会认为函数会调用成功，不考虑异常问题，异常问题是进程该考虑的问题。

💫 线程终止——return、pthread_exit、pthread_cancel

一个新创建出来的线程，如果想终止线程而不是整个进程，有三种做法:

直接从线程函数结束，return的时候，线程就算终止了。
线程可以自己调用pthread_exit函数终止自己。
一个线程可以调用pthread_cancel函数终止同一进程中的另一个线程。

return终止线程：

注意:exit不能用来终止线程，因为exit是来终止进程的。任何一个执行流调用exit都会让整个进程退出，所以终止线程不能采用exit，而是采用return来终止线程。

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

class ThreadData
{
public:
    pthread_t tid;
    char namebuffer[64];
    
};
//创建一批新线程
void* start_routine(void* args)
{
    sleep(1);
    ThreadData *td = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        cout<<"cnt:"<<cnt<<"&cnt:"<<&cnt<<endl;
        cnt--;
        sleep(1);
        return nullptr;
    }
    delete td;
}

int main()
{
    vector<ThreadData*> threads;
#define NUM 10
    for(int i = 0;i<NUM;i++)
    {
        ThreadData *td = new ThreadData();
        snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i+1);
        pthread_create(&td->tid,nullptr,start_routine,td);
        threads.push_back(td);
    }
    for(auto&iter:threads)
    {
        cout<<"create thread: "<<iter->namebuffer<<" : "<<iter->tid<<" sucess" <<endl;
    }
    while(true)
    {
        cout<<"new thread create success,name: main thread"<<endl;
        sleep(1);
    }
    return 0;
}#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

class ThreadData
{
public:
    pthread_t tid;
    char namebuffer[64];
    
};
//创建一批新线程
void* start_routine(void* args)
{
    sleep(1);
    ThreadData *td = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        cout<<"cnt:"<<cnt<<"&cnt:"<<&cnt<<endl;
        cnt--;
        sleep(1);
        return nullptr;
    }
    delete td;
}

int main()
{
    vector<ThreadData*> threads;
#define NUM 10
    for(int i = 0;i<NUM;i++)
    {
        ThreadData *td = new ThreadData();
        snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i+1);
        pthread_create(&td->tid,nullptr,start_routine,td);
        threads.push_back(td);
    }
    for(auto&iter:threads)
    {
        cout<<"create thread: "<<iter->namebuffer<<" : "<<iter->tid<<" sucess" <<endl;
    }
    while(true)
    {
        cout<<"new thread create success,name: main thread"<<endl;
        sleep(1);
    }
    return 0;
}

最终新建线程终止。

pthread_exit函数：

pthread_exit函数的功能就是终止线程：

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

retval:线程退出时的退出码信息，默认设置为nullptr

举个栗子：

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

class ThreadData
{
public:
    pthread_t tid;
    char namebuffer[64];
    
};
//创建一批新线程
void* start_routine(void* args)
{
    sleep(1);
    ThreadData *td = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        cout<<"cnt:"<<cnt<<"&cnt:"<<&cnt<<endl;
        cnt--;
        sleep(1);
    }
    delete td;
    pthread_exit(nullptr);
}
int main()
{
    vector<ThreadData*> threads;
#define NUM 10
    for(int i = 0;i<NUM;i++)
    {
        ThreadData *td = new ThreadData();
        snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i+1);
        pthread_create(&td->tid,nullptr,start_routine,td);
        threads.push_back(td);
    }
    for(auto&iter:threads)
    {
        cout<<"create thread: "<<iter->namebuffer<<" : "<<iter->tid<<" sucess" <<endl;
    }
    while(true)
    {
        cout<<"new thread create success,name: main thread"<<endl;
        sleep(1);
    }
    return 0;
}

pthread_cancel：

线程是可以被其他线程取消的，但是线程要被取消，前提是这个线程是已经运行起来了。pthread_create取消也是线程终止的一种

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

我们以取消一半的线程为例：

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <vector>
using namespace std;

class ThreadData
{
public:
    int number;
    pthread_t tid;
    char namebuffer[64];  
};
//创建一批新线程
void* start_routine(void* args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    int cnt = 10;
    while(cnt)
    {
        cout<<"cnt:"<<cnt<<"&cnt:"<<&cnt<<endl;
        cnt--;
        sleep(1);
    }
  return (void*)100;
}
int main()
{
    vector<ThreadData*> threads;
#define NUM 10
    for(int i = 0;i<NUM;i++)
    {
        ThreadData *td = new ThreadData();
        td->number = i+1;
        snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i+1);
        pthread_create(&td->tid,nullptr,start_routine,td);
        threads.push_back(td);
    }
    for(auto&iter:threads)
    {
        cout<<"create thread: "<<iter->namebuffer<<" : "<<iter->tid<<" sucess" <<endl;
    }
    sleep(5);
    //取消一半的线程
    for(int i = 0;i<threads.size()/2;i++)
    {
        pthread_cancel(threads[i]->tid);
        cout<<"ptheread_cancel : "<<threads[i]->namebuffer<<" success"<<endl;
    }

    for(auto&iter:threads)
    {
        void*ret = nullptr;
        int n = pthread_join(iter->tid,(void**)&ret);
        assert(n==0);
        cout<<"join : "<<iter->namebuffer<<" success,exit_code: "<<(long long)ret<<endl;
        delete iter;
    }
    cout<<"main thread quit"<<endl;
    return 0;
}

线程如果是被取消的，退出码是-1，-1是一个宏，PTHREAD_CANCELED，我们可以查看定义：

#define PTHREAD_CANCELED ((void *) -1)

初步重新认识我们的线程库（语言版）

任何语言，在Linux中，如果要实现多线程，必定要使用pthread库，如何看待C++11中的多线程：C++11的多线程，在Linux环境中本质就是对pthread库的封装。

💫 分离线程——pthread_detach

概念：

线程是可以等待的，等待的时候，是join的等待的，阻塞式等待。而如果线程我们不想等待：不要等待，该去进行分离线程处理。默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏而如果我们不关心线程的返回值，join是一种负担，这个时候我们可以告诉OS，当线程退出时，自动释放线程资源，这种策略就是线程分离。

phread_detach使用：

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

下面我们创建新线程，让主线程与新线程运行起来，主线程等待新线程退出，等待完毕返回n，而现在让创建的新线程进行分离，按照我们的预料：此时应该是等待失败：

#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <vector>
using namespace std;

string changeId(const pthread_t & thread_id)
{
    char tid[128];
    snprintf(tid,sizeof(tid),"0x%x",thread_id);
    return tid;
}
void*start_routine(void*args)
{
    string threadname = static_cast<const char*>(args);
    pthread_detach(pthread_self());//线程分离，设置为分离状态
    int cnt = 5;
    while(cnt--)
    {
        cout<<threadname<<" running ... "<<changeId(pthread_self())<<endl;
        sleep(1);
    }
    return nullptr;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,start_routine,(void*)"thread 1");
    string main_id = changeId(pthread_self());
    cout<<"main thread running... new thread id:"<<changeId(tid)<<"main thread id: "<<main_id<<endl;
    //一个线程默认是joinable的，设置了分离状态，不能够进行等待了
    int n = pthread_join(tid,nullptr);
    cout<<"result:"<<n<<": "<<strerror(n)<<endl;
    return 0;
}