POSIX线程库

引言

前面我们提到了Linux中并无真正意义上的线程
从OS角度来看，这意味着它并不会提供直接创建线程的系统调用，它最多给我们提供创建轻量级进程LWP的接口
但是从用户的角度来看，用户只认识线程啊！
因此，操作系统OS与用户两者之间，必定存在一个桥梁——库
这个线程库，对下能够将Linux提供的LWP进程接口进行封装，对上能够给用户进行线程控制的接口
这个库，我们就称作pthread库，在里面的绝大多数函数的名字都是以“pthread_”打头的
在任何linux系统下，不管版本的老旧，都会默认自带，是一个原生线程库，等下我们也会进行验证

前提

但是，pthread线程库，并非随意就能使用，还需要我们编写代码时，进行一些附加操作

1.要使用这些函数库，要引入头文件<pthread.h>
2.链接这些线程函数库时要使用编译器命令的“-lpthread”选项

 1 mythreadTest:threadTest.cc 2 g++ -o $@ $^ -std=c++11 -lpthread 3 .PHONY:clean 4 clean: 5 rm -f mythreadTest 

线程创建

就像每个文件都有着其对应的inode编号，每个线程也有着自己的编号，它的类型时pthread_t类型
假如在编译器中一直跳转，寻找它最开始的定义

讯享网
可以发现，它实际上就是一个unsigned long类型
不过具体这个编号有什么用，我们先按下不表
我们先介绍创建线程提供的pthread_create函数
man手册查该函数，会给出相应的函数介绍
可以看到该函数位于3号手册中，所以也符合我们前面的讲解，即该函数不是系统调用的函数，而是封装了linux系统的轻量级进程接口的函数
功能是创建一个新线程(create a new thread)

总共有4个参数

第一个参数thread
是线程id的地址(返回线程ID)
第二个参数attr,
设置线程的属性，attr为NULL表示使用默认属性，通常使用的时候都给nullptr，使用默认属性
第三个参数start_routine
是个函数地址，线程启动后要执行的函数,参数是void*,返回参数也是void*，是一个函数指针
第四个参数arg
是等下传给start_routine的参数(传给线程启动函数的参数)

有了上面的基础后，我们就可以先简单创建一个我们的线程
主线程输出对应的线程id
另外一个线程输出自己正在允许

讯享网 1 #include <iostream> 2 #include <unistd.h> 3 4 using namespace std; 5 void* thread_run(void* args) 6 { 
    7 while(true) 8 { 
    9 cout << "new thread is running" << endl; 10 sleep(1); 11 } 12 } 13 14 int main() 15 { 
    16 pthread_t t; 17 pthread_create(&t,nullptr,thread_run,nullptr); 18 19 while(true) 20 { 
    21 cout << "main thread is running,thread id : " << t << endl; 22 sleep(1); 23 } 24 return 0; 25 } 

可以看到，结果符合我们的预期

往命令行窗口输入lld + 对应文件名，即可看到该文件链接了什么库
可以看到，其中有一个pthread库，它对应的路径是/lib64/libpthread,也就和我们之前所说的任何Linux系统默认自带相应的pthread库说法，完美符合

但是我们现在只是创建了一个线程而已，所以，我们的代码肯定还是要改进，创建更多的线程的
我们采取数组的方式，我们知道数组名实际上就是首元素的地址，加上对应的i，实际对应的刚好就是数组里面每个元素的地址，而不用再取地址&
并且，我们可以开始研究第四个参数arg，它是主线程往新线程里面传的参数
那实际上能不能传过去呢？我们对传进来的参数args进行强制类型转换，然后打印相应的内容，假如能够打印相应的内容，则说明args这个参数的确能够是主线程往新线程里面传的参数

 1 #include <iostream> 2 #include <unistd.h> 3 #define NUM 10 4 using namespace std; 5 void* thread_run(void* args) 6 { 
    7 char* name = (char*)args; 8 9 while(true) 10 { 
    11 cout << "new thread: " << name << " is running" << endl; 12 sleep(1); 13 } 14 15 return nullptr; 16 } 17 18 int main() 19 { 
    20 pthread_t tid[NUM]; 21 for (int i = 0;i < NUM;i++) 22 { 
    23 char tname[64]; 24 snprintf(tname,sizeof(tname),"thread-%d",i + 1); 25 pthread_create(tid + i,nullptr,thread_run,tname); 26 } 27 28 29 while(true) 30 { 
    31 cout << "main thread is running" << endl; 32 sleep(1); 33 } 34 return 0; 35 } 

但是，打印出来的结果，却不符合我们的预期
第一，我们预想的是，每个线程的编号都应该不同，即每个线程的名字都不一样，毕竟我们循环往tname这个数组里面放内容的时候，用的是不同的i
第二,有部分线程输出代码紧挨在一起，并且主线程并不是最先运行的，反而是新线程先运行

对于第二个问题，我们其实可以解释，在进程的一章中我们就已经提到过，哪个进程先被调度，其实是不确定的，同样的，线程也是我们调用轻量级进程接口创建出来的，肯定也是符合这个规律，所以谁先被调度，完全取决于调度器决定，先创建的线程，不一定被调度
对于第一个问题，就有点难理解
实际上是由于线程共享的是同一份资源，即便这只是一个临时变量
因此，tname里面存的地址，在不同线程看来都是相同的
所以往里面同时写数据，就会覆盖原有tname空间的旧内容
最后剩下的，仅仅是最后调度的线程的名字
那我们要怎么修改呢？
一种简单的方式，就是直接new相应的空间
(不过要注意，此时使用snprintf函数的时候，就不能再直接sizeof，这样计算的就单纯只会是指针的大小，所以这里直接指定64字节，毕竟整个空间也就64字节)
对于每个线程来说，都会new出新的自己的空间，这样放的数据就不会再被覆盖
相当于每个线程，都有了自己的房子，从此井水不犯河水

讯享网 1 #include <iostream> 2 #include <unistd.h> 3 #define NUM 10 4 using namespace std; 5 void* thread_run(void* args) 6 { 
    7 char* name = (char*)args; 8 9 while(true) 10 { 
    11 cout << "new thread: " << name << " is running" << endl; 12 sleep(1); 13 } 14 delete name; 15 return nullptr; 16 } 17 18 int main() 19 { 
    20 pthread_t tid[NUM]; 21 for (int i = 0;i < NUM;i++) 22 { 
    23 char* tp = new char[64]; 24 snprintf(tp,64,"thread-%d",i + 1); 25 pthread_create(tid + i,nullptr,thread_run,tp); 26 } 27 28 29 while(true) 30 { 
    31 cout << "main thread is running" << endl; 32 sleep(1); 33 } 34 return 0; 35 } 

经过修改后的运行效果，就符合我们的预期了

线程终止

主线程提前退出

假如主线程现在提前退出了，说不再和其它新线程一起玩，会发生什么情况呢？
将上面主线程的代码修改一下，把循环去掉

此时，再编译运行我们的代码，会得到下面的结果
可以看到，一旦主线程退出了，其它的所有新线程，就会全部强制退出

为什么会出现这种情况呢？
就是因为线程是进程的一个执行分支，线程异常了，发送信号是给进程发信号，进程挂了，所有依附于它的线程，全部都走不了，覆巢之下，安有完卵，指的就是这个道理
同样的，假如其中一个线程调用了exit函数，那请问最后的结果会是怎么样呢？
我们同样可以修改相应的代码，在循环中加入相应的exit函数

可以看到，只有几个线程成功输出了自己的编号，程序就自动停止了
所以实际的情况就是，有几个线程成功被创建，但是其中有一个线程执行exit函数，然后全部线程都挂掉了

只要有任何一个线程调用exit函数，整个进程中，所有的线程都会全部退出
关键不是主线程还是新线程的问题，而是大家都是一体的，同生共死

阻塞等待

正是由于线程和进程是有很多相似之处的，进程有父进程阻塞等待，回收子进程的操作
线程也会有相应的概念
主线程需要等待子线程，然后进行相应的回收，否则子线程就会陷入僵尸状态
在pthread库里面就已经提供了相应主线程等待的库函数pthread_join
调用该函数，主线程就会阻塞，并回收相应退出的新线程(join with a terminated thread)

它总共有两个参数‘
第一个参数thread，就是我们之前提到过的线程id
第二个参数retval，是一个二级指针void，为什么是二级指针呢？
因为它是一个输出型参数，早在C语言函数中我们就已经学过，由于C语言中没有引用的概念，因此，在函数内部进行赋值，其实改变的都是形参，并不会改变实参
想要改变实参，就需要传相应的指针
想传int出来，就要int*
想传int出来，就要int作为参数
同理，假如我们返回的参数此时是一个void类型的，那用void接收，也就非常合理了

它的返回值和前面提到过的pthread_create函数相同
成功的话，就返回0；否则，返回一个错误的数字

 1 #include <iostream> 2 #include <unistd.h> 3 #define NUM 10 4 using namespace std; 5 void* thread_run(void* args) 6 { 
    7 char* name = (char*)args; 8 9 while(true) 10 { 
    11 cout << "new thread: " << name << " is running" << endl; 12 sleep(1); 13 } 14 delete name; 15 return nullptr; 16 } 17 18 int main() 19 { 
    20 pthread_t tid[NUM]; 21 for (int i = 0;i < NUM;i++) 22 { 
    23 char* tp = new char[64]; 24 snprintf(tp,64,"thread-%d",i + 1); 25 pthread_create(tid + i,nullptr,thread_run,tp); 26 } 27 28 for (int i = 0;i < NUM;i++) 29 { 
    30 pthread_join(tid[i],nullptr); 31 } 32 33 return 0; 34 } 

终止方式

既然，我们知道主线程，需要阻塞等待子线程退出，并回收相应的子线程
那了解子线程有多少种退出方式，就非常有必要
子线程总共有三种退出方式
第一种方式，线程函数执行完毕，此时直接返回nullptr，线程就会退出

讯享网 1 #include <iostream> 2 #include <unistd.h> 3 #define NUM 10 4 using namespace std; 5 void* thread_run(void* args) 6 { 
    7 char* name = (char*)args; 8 9 while(true) 10 { 
    11 cout << "new thread: " << name << " is running" << endl; 12 sleep(1); 13 break; 14 } 15 delete name; 16 return nullptr; 17 } 18 int main() 19 { 
    20 pthread_t tid[NUM]; 21 for (int i = 0;i < NUM;i++) 22 { 
    23 char* tp = new char[64]; 24 snprintf(tp,64,"thread-%d",i + 1); 25 pthread_create(tid + i,nullptr,thread_run,tp); 26 } 27 28 for (int i = 0;i < NUM;i++) 29 { 
    30 int n = pthread_join(tid[i],nullptr); 31 //errno变量只有一个，而线程有多个，作同时修改，可能会互相影响  32 if(n!= 0) cerr << "pthread_join error" << endl; 33 } 34 35 return 0; 

第二种方式，pthread库里面提供了相应的线程退出函数pthread_exit

它的参数retval，为一个输出型参数
没错，和我们之前提到的pthread_join的参数名字是相同的，也就意味着两者肯定有所关联
通过返回retval，我们对应的主线程就可以接收到对应的错误信息
那为什么我们不通过设置全局变量errno来输出对应的错误信息呢？
因为不同线程对于这个全局变量是共享的，全部线程都同时使用一个全局变量，就可能会出现覆盖等等问题，导致出错了也可能不知道
因此，pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）
而是将错误码通过返回值返回
还有一个好处是，对于pthreads函数的错误，通过返回值判定，要比读取线程内的errno变量的开销更小

 1 #include <iostream> 2 #include <unistd.h> 3 #define NUM 10 4 using namespace std; 5 void* thread_run(void* args) 6 { 
    7 char* name = (char*)args; 8 9 while(true) 10 { 
    11 cout << "new thread: " << name << " is running" << endl; 12 break; 13 } 14 delete name; 15 pthread_exit(nullptr); 16 } 17 18 19 int main() 20 { 
    21 pthread_t tid[NUM]; 22 for (int i = 0;i < NUM;i++) 23 { 
    24 char* tp = new char[64]; 25 snprintf(tp,64,"thread-%d",i + 1); 26 pthread_create(tid + i,nullptr,thread_run,tp); 27 } 28 29 for (int i = 0;i < NUM;i++) 30 { 
    31 int n = pthread_join(tid[i],nullptr); 32 //errno变量只有一个，而线程有多个，作同时修改，可能会互相影响 33 if(n!= 0) cerr << "pthread_join error" << endl; 34 } 35 cout << "all thread quit" << endl; 36 return 0; 37 } 

讯享网 1 #include <iostream> 2 #include <unistd.h> 3 #include <pthread.h> 4 #include <string> 5 #include <ctime> 6 #define NUM 10 7 using namespace std; 8 9 10 class ThreadData 11 { 
    12 public: 13 ThreadData(const string& name,int id,time_t createTime):_name(name),_id(id),_createTime((uint64_t)createTime) 14 { 
   } 15 ~ThreadData() 16 { 
   } 17 public: 18 string _name; 19 int _id; 20 uint64_t _createTime; 21 }; 22 void* thread_run(void* args) 23 { 
    24 ThreadData* tp = static_cast<ThreadData*>(args); 25 26 while(true) 27 { 
    28 cout << "thread is running,name: " << tp->_name << " create time: "<< tp->_createTime << " index:" << tp->_id << endl; 29 break; 30 } 31 delete tp; 32 pthread_exit((void*)2); 33 } 34 35 36 int main() 37 { 
    38 pthread_t tid[NUM]; 39 for (int i = 0;i < NUM;i++) 40 { 
    41 char tname[64]; 42 snprintf(tname,sizeof(tname),"thread-%d",i + 1); 43 ThreadData* tp = new ThreadData(tname,i + 1,time(nullptr)); 44 pthread_create(tid + i,nullptr,thread_run,tp); 45 } 46 47 void* ret = nullptr; 48 for (int i = 0;i < NUM;i++) 49 { 
    50 int n = pthread_join(tid[i],&ret); 51 //errno变量只有一个，而线程有多个，作同时修改，可能会互相影响 52 if(n!= 0) cerr << "pthread_join error" << endl; 53 54 cout << "thread quit: " << (uint64_t)ret << endl; 55 } 56 cout << "all thread quit" << endl; 57 return 0; 58 } 

最后一种方式，是一个线程可以调用pthread_ cancel函数终止同一进程中的另一个线程

整个函数只需要一个参数，也即是我们的线程id
它的功能就是取消一个执行中的线程
成功返回0；反之，则返回错误码

类型转换

在C，或者C++中，我们都知道，一个类型的值赋值给不匹配的类型变量，就会发生报错
但是，我们仔细思考一下，在计算机的眼里，不同数据有区别吗？
都只是0，1的集合罢了
所以，报错是编译器检测发现你类型不匹配，然后报错，显示无法编译你的代码
所谓的类型转换，就是让我们骗过编译器，让数据能够赋到我们想要的变量中
比如说下面的代码，1还是那个1，但是是int类型
你需要将它类型转换，告诉编译器，这个1其实是一个地址，这样才能成功赋值

void* ret = (void*)1;

void*

所以，为什么无论是我们pthread_create函数，还是我们的pthread_exit函数，它们的参数中，设计的都是void*
为的是什么？
为的就是我们让我们传入参数和返回参数的可塑性更强，它并非局限我们只能传一个字符串作为线程函数传入参数，或者只能返回对应的错误码
我们是可以传int，double*等等所有的指针，甚至我们是可以传对象指针进去！！！*
只需要void*接收，然后再类型转换为我们想要的类型，就可以让OS找到对应的资源！！！
下面这段代码，就实现了传一个对象进去线程函数里面，并且通过返回这个对象的指针，将里面处理好的结果带出来

整段代码实现的功能
就是让不同的线程，分别实现从1到对应top数字的求和
原本的串行执行，转变为现在的并发执行

 1 #include <iostream> 2 #include <unistd.h> 3 #include <pthread.h> 4 #include <string> 5 #include <ctime> 6 #define NUM 10 7 using namespace std; 8 enum{ 
    ERROR = 0,OK }; 9 10 class ThreadData 11 { 
    12 public: 13 ThreadData(const string& name,int id,time_t createTime,int top):_name(name),_id(id),_createTime((uint64_t)createTime),_status(OK),_top(top),_result(0) 14 { 
   } 15 ~ThreadData() 16 { 
   } 17 public: 18 //传入的参数 19 string _name; 20 int _id; 21 uint64_t _createTime; 22 23 //返回的参数 24 int _status; //该线程的参数 25 int _top; 26 int _result; //结果是什么 27 //char arr[n]; 28 }; 29 void* thread_run(void* args) 30 { 
    31 ThreadData* tp = static_cast<ThreadData*>(args); 32 33 for (int i = 1;i <= tp->_top;i++) 34 { 
    35 tp->_result += i; 36 } 37 38 cout << "tp->_name: " << tp->_name << endl; 39 return tp; 40 } 41 42 int main() 43 { 
    44 pthread_t tid[NUM]; 45 for (int i = 0;i < NUM;i++) 46 { 
    47 char tname[64]; 48 snprintf(tname,64,"thread-%d",i + 1); 49 //多传入一个参数，用来在创建线程，执行相应任务所加到的对应的数字 50 ThreadData* tp = new ThreadData(tname,i + 1,time(nullptr),100 + 4*i); 51 pthread_create(tid + i,nullptr,thread_run,tp); 52 sleep(1); 53 } 54 55 void* ret = nullptr; 56 for (int i = 0;i < NUM;i++) 57 { 
    58 int n = pthread_join(tid[i],&ret); 59 //errno变量只有一个，而线程有多个，作同时修改，可能会互相影响 60 if(n!= 0) cerr << "pthread_join error" << endl; 61 ThreadData* tp = static_cast<ThreadData*> (ret); 62 if (tp->_status == OK) 63 { 
    64 cout << "thread name: " << tp->_name << " 计算的结果为:" << tp->_result << "[0," << tp->_top << "]" << endl; 65 } 66 delete tp; 67 } 68 cout << "all thread quit" << endl; 69 return 0; 70 } 

输出的结果如下图所示：

让线程获取自己的线程id

那线程有自己的编号，能不能让线程获取对应自己的编号呢？
pthread库中也提供了相应的接口pthread_self

函数参数是没有的，直接调用即可输出当前线程的id是什么
我们可以编写一段程序，来看看对应的线程id，同时返回到主线程，也打印出来对比一下

讯享网 1 #include <iostream> 2 #include <unistd.h> 3 #include <pthread.h> 4 #include <string> 5 #include <ctime> 6 #define NUM 10 7 using namespace std; 8 9 void* thread_create(void* args) 10 { 
    11 const char* name = static_cast<const char*>(args); 12 int cnt = 5; 13 while(cnt--) 14 { 
    15 cout << name << " is running..." << " obtain my tid: " << pthread_self()<< endl; 16 sleep(1); 17 } 18 19 pthread_exit((void*)11); 20 } 21 int main() 22 { 
    23 pthread_t tid; 24 pthread_create(&tid,nullptr,thread_create,(void*)"thread 1"); 25 26 void* ret = nullptr; 27 int n = pthread_join(tid,&ret); 28 if (n != 0) cerr << "thread_join error: " << endl; 29 cout << "new thread exit: " << (uint64_t)ret << endl; 30 cout << " quit thread id: " << tid << endl; 31 return 0; 32 } 

可以看到线程的id通过pthread_self函数，是能够成功获取的

分离线程

前面我们提到，主线程会阻塞等待新线程退出
但是阻塞等待，也就意味着在这期间，主线程并不能干任何事情
那假如我们想要主线程不阻塞等待，让新线程自己回收自己，又应该怎么操作呢？
pthread库中实际上，确实提供类似的接口函数pthread_detach
默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏
但假如我们不关心线程的返回值，join是一种负担，此时，我们就可以修改对应线程的属性，让线程自己退出时，自动释放资源

PS：假如一个线程分离detach后，此时就不能再join了，函数会发生报错
即joinable和分离是冲突的，一个线程不能既是joinable又是分离的

下面，我们简单写一段代码来验证joinable和分离，两者是冲突的这个结论

 1 #include <iostream> 2 #include <pthread.h> 3 #include <unistd.h> 4 #include <cstring> 5 #include <string> 6 using namespace std; 7 void* threadRoutine(void* args) 8 { 
    9 string name = static_cast<const char*>(args); 10 int cnt = 5; 11 while(cnt) 12 { 
    13 cout << name << " : " << cnt-- << endl; 14 sleep(1); 15 } 16 return nullptr; 17 } 18 int main() 19 { 
    20 pthread_t tid; 21 pthread_create(&tid,nullptr,threadRoutine,(void*)"thread 1"); 22 pthread_detach(tid); 23 int n = pthread_join(tid,nullptr); 24 if(0 != n) 25 { 
    26 cerr << "error: " << n << " : "<< strerror(n) << endl; 27 } 28 return 0; 29 30 } 

我们再创建一个新线程后，再detach掉对应的新线程
可以看到运行结果显示，程序会直接发生报错

但除了在主线程进行detach外，也可以在新线程中，让新线程自己detach
比如说下面的代码

讯享网 1 #include <iostream> 2 #include <pthread.h> 3 #include <unistd.h> 4 #include <cstring> 5 #include <string> 6 using namespace std; 7 void* threadRoutine(void* args) 8 { 
    9 pthread_detach(pthread_self()); 10 string name = static_cast<const char*>(args); 11 12 int cnt = 5; 13 while(cnt) 14 { 
    15 cout << name << " : " << cnt-- << endl; 16 sleep(1); 17 } 18 return nullptr; 19 } 20 int main() 21 { 
    22 pthread_t tid; 23 pthread_create(&tid,nullptr,threadRoutine,(void*)"thread 1"); 24 int n = pthread_join(tid,nullptr); 25 if(0 != n) 26 { 
    27 cerr << "error: " << n << " : "<< strerror(n) << endl; 28 } 29 return 0; 30 31 } 

但是运行的结果却并不符合预期，我们并没有看到报错，可以发现新线程照样可以正常跑

这是为什么呢？
原因就在于我们刚开始说的，线程谁先执行并不确定，线程可能被创建出来，但是并没有运行
在上述的代码中就是如此，新线程虽然被创建了，但是并没有被允许
此时主线程检测新线程的属性，可以发现仍然是joinable的，然后允许相关的join代码，主线程被挂起，此时新线程才被执行
因此，假如我们要让新线程自己释放自己的资源的话，我们还需要先让主线程sleep上对应的秒数，让新线程先执行

此时允许的结果就符合我们之前的说法了

正是由于这个的缘故，因此我们一般分离线程，采取的方式都是建议主线程直接detach，而不是自detach