【关于Linux中----多线程（二）线程终止、分离与封装、线程库以及线程id的解析】

文章目录

一、pthread_cancel终止线程

上一篇文章中已经讲述了两种终止线程的方式，这里介绍第三种方式：

这里对上篇文章中的代码稍作修改：

#include<iostream>#include<pthread.h>#include<cassert>#include<unistd.h>#include<cstdio>#include<vector>usingnamespace std;classThreadData{public:int number;
  pthread_t tid;char namebuffer[64];};//新线程void*start_routine(void* args){
  ThreadData* td=static_cast<ThreadData*>(args);int cnt=3;while(cnt){
    cout<<"新线程running! name : "<<td->namebuffer<<"cnt : "<<cnt--<<endl;sleep(1);}return(void*)td->number;}intmain(){
  vector<ThreadData*> threads;#defineNUM3for(int i=0;i<NUM;i++){
    ThreadData* td=newThreadData();snprintf(td->namebuffer,sizeof(td->namebuffer),"%s:%d","thread",i);pthread_create(&td->tid,nullptr,start_routine,td);
    td->number=i;
    threads.push_back(td);}for(auto& iter:threads){
    cout<<"create thread: "<<iter->namebuffer<<":"<<iter->tid<<"successfully!"<<endl;}sleep(3);for(auto& iter:threads){pthread_cancel(iter->tid);
    cout<<"pthread_cancel: "<<iter->namebuffer<<"successfully!"<<endl;}for(auto& iter:threads){void* ret=nullptr;int n=pthread_join(iter->tid,&ret);assert(n==0);
    cout<<"join : "<<iter->namebuffer<<"successfully! exitcode:"<<(longlong)ret<<endl;delete iter;}
  cout<<"主线程退出!"<<endl;return0;}

运行结果如下：

[sny@VM-8-12-centos practice]$ ./mythread
新线程running! name : thread:0cnt : 新线程running! name : thread:1cnt :33
新线程running! name : thread:2cnt :3
create thread: thread:0:140206706472704successfully!
create thread: thread:1:140206698080000successfully!
create thread: thread:2:140206689687296successfully!
新线程running! name : thread:1cnt :2
新线程running! name : thread:2cnt :2
新线程running! name : thread:0cnt :2
新线程running! name : thread:1cnt :1
新线程running! name : 新线程running! name : thread:0cnt :1
thread:2cnt :1
pthread_cancel: thread:0successfully!
pthread_cancel: thread:1successfully!
pthread_cancel: thread:2successfully!join: thread:0successfully! exitcode:-1
join: thread:1successfully! exitcode:-1
join: thread:2successfully! exitcode:-1
主线程退出!

根据记过可知，线程如果是被取消的，它的退出码是-1.
这里需要注意，线程可以被取消的前提是该线程已经运行起来了。

二、初步认识线程库

上一篇文章中以及这篇文章开头谈的都是Linux环境下的线程，下面先用C++的方式创建一个线程，代码如下：

#include<iostream>#include<unistd.h>#include<thread>voidthread_run(){
  std::cout<<"新线程running..."<<std::endl;sleep(1);}intmain(){
  std::thread t1(thread_run);while(true){
    std::cout<<"主线程running..."<<std::endl;sleep(1);}
  t1.join();return0;}

接下来将Makefile中内容作如下修改：

mythread:mythread.cpp
    g++ -o $@ $^ -std=c++11
.PHONY:clean 
clean:
    rm -f mythread

将代码保存后，再运行，结果会报错，因为Makefile中并没有指定使用的线程库。当加上线程库之后就可以正常运行。
这说明，C++11中的多线程在Linux环境下，本质是对pthread的封装。

三、线程分离

上一篇文章中说到使用pthread_join等待线程，本质上是阻塞式的等待，如果不等待线程就不能获取线程退出时的信息，也很有可能造成类似于僵尸进程的结果。
那如果我们现在不希望主线程一直等待新线程，又不想造成像僵尸进程这样的结果呢？

为解决这个问题，就要使用线程分离了。

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

分离线程首先需要了解一个函数接口为pthread_self：

实例代码如下：

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

std::string change_id(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<constchar*>(args);while(true){
        std::cout<<threadname<<"running..."<<change_id(pthread_self())<<std::endl;sleep(1);}}intmain(){
    pthread_t tid;//创建新线程，并让其执行start_routine函数pthread_create(&tid,nullptr,start_routine,(void*)"线程1");
    std::cout<<"主线程running... 新线程id:"<<change_id(tid)<<std::endl;pthread_join(tid,nullptr);return0;}

对应的Makefile内容如下：

mythread:mythread.cc
    g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
    rm -f mythread

运行结果如下：

[sny@VM-8-12-centos threaddone]$ ./mythread
主线程running... 新线程id:0xefdf5700线程1running...0xefdf5700
线程1running...0xefdf5700
线程1running...0xefdf5700

可以看到获取到的线程id是一样的
也可以将主线程的id输出出来，看二者是否相同，这需要将上述代码稍作改动：

intmain(){
    pthread_t tid;//创建新线程，并让其执行start_routine函数pthread_create(&tid,nullptr,start_routine,(void*)"线程1");
    std::cout<<"主线程id: "<<change_id(pthread_self())<<std::endl;
    std::cout<<"主线程running... 新线程id:"<<change_id(tid)<<std::endl;pthread_join(tid,nullptr);return0;}

结果如下：

[sny@VM-8-12-centos threaddone]$ ./mythread
主线程id: 线程10xd076b740running...0xcf6d7700
主线程running... 新线程id:0xcf6d7700
线程1running...0xcf6d7700
线程1running...0xcf6d7700

很明显二者id不同，以上就是pthread_self的用法。

随后，来介绍线程分离应该用到的函数接口：pthread_detach：

实例代码如下（对上文中的代码修改两个函数中的内容）：

void*start_routine(void* args){
    std::string threadname=static_cast<constchar*>(args);pthread_detach(pthread_self());//设置自己为分离状态int cnt=3;while(cnt--){
        std::cout<<threadname<<"running..."<<change_id(pthread_self())<<std::endl;sleep(1);}}intmain(){
    pthread_t tid;//创建新线程，并让其执行start_routine函数pthread_create(&tid,nullptr,start_routine,(void*)"线程1");
    std::cout<<"主线程running... 新线程id:"<<change_id(tid)<<std::endl;//通过观察等待结果验证“一个线程默认是joinable的线程分离后就不能继续等待了”sleep(2);//让主线程sleep两秒已确保新线程已经分离int n=pthread_join(tid,nullptr);
    std::cout<<"线程等待结果："<<n<<":"<<strerror(n)<<std::endl;return0;}

结果如下：

[sny@VM-8-12-centos threaddone]$ ./mythread
主线程running... 新线程id:0x3a42f700线程1running...0x3a42f700
线程1running...0x3a42f700
线程等待结果：22:Invalid argument

最终等待失败，“线程分离之后就不能进行等待了”验证成功！
这里再补充一点，使用pthread_detach分离线程时，最好让主线程来完成这个工作。

以上就是线程分离的操作。

四、对于线程id的解析

在上一篇文章中还有一个未解决的问题，就是最终输出的线程id到底有什么含义？
以及之前说过的每一个线程都应该有自己独立的上下文结构、栈结构等等，那么又该怎么理解呢？

先来回顾一下之前解释过的原生的线程库中，可能同时存在多个线程，也可能有多个用户同时使用线程接口创建多个线程，所以我们需要将多个线程管理起来。虽然线程的属性较少，但同样需要管理。
而pthread原生线程库中会为每一个线程创建结构体来存放它们的属性，这些线程叫做用户级线程，由内核提供线程执行流的调度，Linux用户级线程：内核级轻量进程为1：1

那么用户级线程究竟是什么？

首先需要知道，我们一直在说的pthread线程库实际上就是一个磁盘文件，当某一进程需要创建新的线程的时候就将其加载到内存中使用，它被加载到内存中的位置叫做共享区。
而进程地址空间中有一个叫做mmap的区域，这个区域经过页表映射之后就能找到具体的物理内存中，线程库对应的位置。然后可以在其中为每一个线程创建自己的结构体、栈结构等等。如图：

而所谓线程的id就是每一个TCB的起始位置，线程的独立站结构就是原生线程库中为每一个线程提供的线程栈。

再对线程局部存储做一个解释：

根据之前的解释，定义在全局的变量是一个进程中所有执行流的共享资源，即任意一个执行流对其进行修改，其他的所有执行流都可以看到，例如下面代码中的全局变量g_val：

int g_val=10;

std::string change_id(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<constchar*>(args);while(true){
        std::cout<<threadname<<"running..."<<"g_val:"<<g_val<<" &g_val:"<<&g_val<<std::endl;
        g_val++;sleep(1);}}intmain(){
    pthread_t tid;pthread_create(&tid,nullptr,start_routine,(void*)"新线程");while(true){
        std::cout<<"主线程running... "<<"g_val:"<<g_val<<" &g_val:"<<&g_val<<std::endl;sleep(1);}return0;}

执行结果如下：

[sny@VM-8-12-centos threaddone]$ ./mythread
主线程running... g_val:10 &g_val:0x6020c4
新线程running...g_val:10 &g_val:0x6020c4
主线程running... g_val:11 &g_val:0x6020c4
新线程running...g_val:11 &g_val:0x6020c4
主线程running... g_val:12 &g_val:0x6020c4
新线程running...g_val:12 &g_val:0x6020c4
主线程running... g_val:13 &g_val:0x6020c4
新线程running...g_val:13 &g_val:0x6020c4

可以看到，新线程每一次修改全局变量，主线程都能看到，并且两个线程拿到的全局变量的地址都是一样的。

接下来在g_val前加一个__thread,如下：

__thread int g_val=10;

再次运行，结果如下：

[sny@VM-8-12-centos threaddone]$ ./mythread
主线程running... g_val:10 &g_val:0x7fc6fd57a77c
新线程running...g_val:10 &g_val:0x7fc6fc4e66fc
主线程running... g_val:10 &g_val:0x7fc6fd57a77c
新线程running...g_val:11 &g_val:0x7fc6fc4e66fc
新线程running...主线程running... g_val:g_val:1012 &g_val: &g_val:0x7fc6fd57a77c0x7fc6fc4e66fc

主线程running... g_val:0xa &g_val:0x7fc6fd57a77c
新线程running...g_val:0xd &g_val:0x7fc6fc4e66fc
主线程running... g_val:0xa&g_val:0x7fc6fd57a77c

很明显的可以看到，这次新线程不停地修改全局变量的值，但主线程却看不到了，而且两个线程拿到的全局变量的地址都是不一样的。
所以，__thread可以将内置类型变为线程局部存储。

五、对线程进行封装

所谓的封装，就是将一些接口融合进一个类中，下次想要使用这些接口的功能时，直接调用类对象的成员函数即可，封装后的代码如下：

#pragmaonce#include<iostream>#include<string>#include<functional>#include<pthread.h>#include<cassert>classThread;classContext{public:
    Thread* this_;void* args_;public:Context():this_(nullptr),args_(nullptr){}~Context(){}};classThread{typedef std::function<void*(void*)> func_t;constint num=1024;public:Thread(func_t func,void* args,int number):func_(func),args_(args){char buffer[num];snprintf(buffer,sizeof buffer,"thread-%d",number);
        name_=buffer;
        Context* ctx=newContext();
        ctx->this_=this;
        ctx->args_=args_;int n=pthread_create(&tid_,nullptr,start_routine,ctx);assert(n==0);(void)n;//主要是告诉编译器这个变量已经被使用了，因为assert在release下是失效的}//start直接使用func_会报错，该函数为辅助函数//在类捏创建线程，要让线程执行对应的方法，需要将其设置为staticstaticvoid*start_routine(void* args)//有缺省参数this{//静态成员不能调用成员变量和成员方法
        Context* ctx=static_cast<Context*>(args);void* ret=ctx->this_->run(ctx->args_);delete ctx;return ret;}voidjoin(){int n=pthread_join(tid_,nullptr);assert(n==0);(void)n;}void*run(void* args){func_(args);}~Thread(){//nothing}private:
    std::string name_;
    pthread_t tid_;
    func_t func_;void* args_;};

接下来用上面封装后的类创建三个线程看看效果：

#include<iostream>#include<pthread.h>#include<string>#include<unistd.h>#include<cstdio>#include<cstring>#include<memory>#include"thread.hpp"void*thread_run(void* args){
    std::string work_type=static_cast<constchar*>(args);while(true){
        std::cout<<"新线程 "<<work_type<<"ing"<<std::endl;sleep(1);}}intmain(){
    std::unique_ptr<Thread>thread1(newThread(thread_run,(void*)"mul",0));
    std::unique_ptr<Thread>thread2(newThread(thread_run,(void*)"add",1));
    std::unique_ptr<Thread>thread3(newThread(thread_run,(void*)"sub",2));

    thread1->join();
    thread2->join();
    thread3->join();return0;}

分别让三个线程执行按死不同的动作，结果如下：

[sny@VM-8-12-centos threaddone]$ ./mythread
新线程 muling新线程 adding
新线程 subing
新线程 adding
新线程 subing
新线程 muling

在以后创建线程时，也可以直接使用这个封装之后的类，会方便很多。

本篇完，青山不改，绿水长流！