文章目录

• 一、pthread_cancel终止线程
• 二、初步认识线程库
• 三、线程分离
• 四、对于线程id的解析
• 五、对线程进行封装

---

一、pthread_cancel终止线程

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

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

#include <iostream>
#include <pthread.h>
#include <cassert>
#include <unistd.h>
#include <cstdio>
#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=3;
  while(cnt)
  {
    cout<<"新线程running! name : "<<td->namebuffer<<"cnt : "<<cnt--<<endl;
    sleep(1);
  }
  return (void*)td->number;
}

int main()
{
  vector<ThreadData*> threads;
#define NUM 3
  for(int i=0;i<NUM;i++)
  {
    ThreadData* td=new ThreadData();
    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:"<<(long long)ret<<endl;
    delete iter;
  }
  cout<<"主线程退出!"<<endl;
  return 0;
}

运行结果如下：

[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>

void thread_run()
{
  std::cout<<"新线程running..."<<std::endl;
  sleep(1);
}

int main()
{
  std::thread t1(thread_run);
  while(true)
  {
    std::cout<<"主线程running..."<<std::endl;
    sleep(1);
  }
  t1.join();
  return 0;
}

接下来将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<const char*>(args);
    while(true)
    {
        std::cout<<threadname<<"running..."<<change_id(pthread_self())<<std::endl;
        sleep(1);
    }
}
int main()
{
    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);
    return 0;
}

对应的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输出出来，看二者是否相同，这需要将上述代码稍作改动：

int main()
{
    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);
    return 0;
}

结果如下：

[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<const char*>(args);
    pthread_detach(pthread_self());//设置自己为分离状态
    int cnt=3;
    while(cnt--)
    {
        std::cout<<threadname<<"running..."<<change_id(pthread_self())<<std::endl;
        sleep(1);
    }
}
int main()
{
    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;
    return 0;
}

结果如下：

[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<const char*>(args);
    while(true)
    {
        std::cout<<threadname<<"running..."<<"g_val:"<<g_val<<" &g_val:"<<&g_val<<std::endl;
        g_val++;
        sleep(1);
    }
}

int main()
{
    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);
    }
    return 0;
}

执行结果如下：

[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可以将内置类型变为线程局部存储。

---

五、对线程进行封装

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

#pragma once
#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>
#include <cassert>

class Thread;

class Context
{
public:
    Thread* this_;
    void* args_;
public:
    Context()
        :this_(nullptr)
        ,args_(nullptr)
    {}
    ~Context()
    {}
};

class Thread
{
    typedef std::function<void*(void*)> func_t;
    const int 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=new Context();
        ctx->this_=this;
        ctx->args_=args_;
        int n=pthread_create(&tid_,nullptr,start_routine,ctx);
        assert(n==0);
        (void)n;//主要是告诉编译器这个变量已经被使用了，因为assert在release下是失效的
    }
    //start直接使用func_会报错，该函数为辅助函数
    //在类捏创建线程，要让线程执行对应的方法，需要将其设置为static
    static void* start_routine(void* args) //有缺省参数this
    {//静态成员不能调用成员变量和成员方法
        Context* ctx=static_cast<Context*>(args);
        void* ret=ctx->this_->run(ctx->args_);
        delete ctx;
        return ret;
    }

    void join()
    {
        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<const char*>(args);
    while(true)
    {
        std::cout<<"新线程 "<<work_type<<"ing"<<std::endl;
        sleep(1);
    }
}

int main()
{
    std::unique_ptr<Thread> thread1(new Thread(thread_run,(void*)"mul",0));
    std::unique_ptr<Thread> thread2(new Thread(thread_run,(void*)"add",1));
    std::unique_ptr<Thread> thread3(new Thread(thread_run,(void*)"sub",2));

    thread1->join();
    thread2->join();
    thread3->join();
    return 0;
}

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

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

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

---

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