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 }
经过修改后的运行效果，就符合我们的预期了
线程终止
前面我们提到了在linux系统下，是没有对应具体线程的实现！而是采用复用的方式
所以，进程有的特性，线程往往也会有
主线程提前退出
假如主线程现在提前退出了，说不再和其它新线程一起玩，会发生什么情况呢？
将上面主线程的代码修改一下，把循环去掉
此时，再编译运行我们的代码，会得到下面的结果
可以看到，一旦主线程退出了，其它的所有新线程，就会全部强制退出
为什么会出现这种情况呢？
就是因为线程是进程的一个执行分支，线程异常了，发送信号是给进程发信号，进程挂了，所有依附于它的线程，全部都走不了，覆巢之下，安有完卵，指的就是这个道理
同样的，假如其中一个线程调用了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;
进一步思考的话，类型转换也告诉了OS，这究竟是什么类型变量
这非常关键，决定我们将它存到哪里，它的偏移地址是什么等等，这样我们以后才能成功访问到这个数据
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
1111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
