Linux:42线程控制lesson30

代码1：验证join可以去的线程实行完后的退出码/返回值

2. #include<iostream>
3. #include<unistd.h>
4. #include<pthread.h>
5. #include<string>
6. using namespace std;
8. void* routine(void* arg){
9.     string name = static_cast<const char*>(arg);
10.     int cnt = 5;
11.     while(cnt--)
12.     {
13.         cout<<"我是子线程，名字："<<name<<endl;
14.         sleep(1);
15.     }
16.     return (void*)10;
17. }
19. int main(){
20.     pthread_t tid;
21.     pthread_create(&tid,nullptr,routine,(void*)"thread-1");
22.     int cnt = 5;
23.     while(cnt--){
24.         cout<<"我是主线程"<<endl;
25.         sleep(1);
26.     }
27.     void* ret = nullptr;
28.     pthread_join(tid,&ret);
29.     cout<<"子进程退出，退出码为："<<(long long)ret<<endl;
30. }

复制代码

 

1.main函数竣事，代表主线程竣事，也代表历程竣事
2.新线程对应的入口函数，运行竣事，代表当前线程运行竣事。
3.问题：给线程通报的参数和返回值，可以是恣意范例 
代码2：30min证实：：给线程通报的参数和返回值，可以是恣意范例 ，下面的例子是类范例

2. #include<iostream>
3. #include<unistd.h>
4. #include<pthread.h>
5. #include<string>
6. using namespace std;
8. class Task{
9.     public:
10.         Task(int a,int b)
11.             :_a(a)
12.             ,_b(b)
13.             {}
14.         int Cal(){
15.             return _a+_b;
16.         }
17.         ~Task() {}
18.     private:
19.         int _a;
20.         int _b;
21. };
22. class Result{
23.     public:
24.         Result(int result)
25.             :_result(result)
26.             {}
27.         int getresult(){
28.             return _result;
29.         }
30.         ~Result(){}
31.     private:
32.         int _result;
33. };
34. void* routine(void* arg){
35.     Task*t = static_cast<Task*>(arg);
36.     sleep(1);
37.     Result* r = new Result(t->Cal());
38.     sleep(1);
39.     return r;
40. }
42. int main(){
43.     pthread_t tid;
44.     Task* t = new Task(20,10);
45.     pthread_create(&tid,nullptr,routine,t);
47.     Result* ret = nullptr;
48.     pthread_join(tid,(void**)&ret);
49.     int n = ret->getresult();
50.     cout<<"子线程的返回值是："<<n<<endl;
51. }

复制代码

 

线程停止 

假如必要只终⽌某个线程⽽不终⽌整个历程,可以有三种⽅法:
1. 从线程函数return。这种⽅法对主线程不适⽤,从main函数return相称于调⽤exit。
2. 线程可以调⽤pthread_exit终⽌⾃⼰。
3. ⼀个线程可以调⽤pthread_cancel终⽌同⼀历程中的另⼀个线程。
 
pthread_exit:线程停止

2. 功能：线程终⽌
3. 原型:
4. void pthread_exit(void *value_ptr);
7. 参数:
8. value_ptr:value_ptr不要指向⼀个局部变量，就是指的一个变量
9. pthread_exit 的参数 value_ptr 是一个指向某个值的指针，该值将作为线程的返回值。这个返回值可以被主线程通过 pthread_join 获取。
11. 返回值：
13. ⽆返回值，跟进程⼀样，线程结束的时候⽆法返回到它的调⽤者（⾃⾝）

复制代码

和return是等价的。 
线程期待 ：pthread_join

为什么必要线程期待？

• 已经退出的线程，其空间没有被释放，仍然在历程的地址空间内。用来释放空间
• 创建新的线程不会复⽤刚才退出线程的地址空间。

2. 功能：等待线程结束
3. 原型
5. int pthread_join(pthread_t thread, void **value_ptr);
8. 参数:
9. thread:线程ID
10. value_ptr:它指向⼀个指针，后者指向线程的返回值
14. 返回值：成功返回0；失败返回错误码

复制代码

 历程以差别的方式停止，pthread_join得到的线程返回值是不一样的

调⽤该函数的线程将挂起期待,直到id为thread的线程终⽌。thread线程以差别的⽅法终⽌,通过 pthread_join得到的终⽌状态是差别的，总结如下:

2. 1. 如果thread线程通过return返回,
3. value_ptr所指向的单元⾥存放的是thread线程函数的返回值。
5. 2. 如果thread线程被别的线程调⽤pthread_cancel异常终掉,
6. value_ptr所指向的单元⾥存放的是常 数PTHREAD_CANCELED。
8. 3. 如果thread线程是⾃⼰调⽤pthread_exit终⽌的,
9. value_ptr所指向的单元存放的是传给 pthread_exit的参数。
11. 4. 如果对thread线程的终⽌状态不感兴趣,可以传NULL给value_ptr参数。

复制代码

pthread_cancel:取消线程 

参数：tid 
主线程取消新线程
取消的时候肯定要包管：新线程已经启动 

 线程被取消，返回的结果是-1
表明:线程假如被取消退出的结果是-1

最保举的还是return, 

线程分离 ：pthread_detach(tid)

• 默认情况下，新创建的线程是joinable的，线程退出后，必要对其进⾏pthread_join操纵，否则 ⽆法释放资源，从⽽造成系统走漏。
• 假如不关⼼线程的返回值，join是⼀种负担，这个时候，我们可以告诉系统，当线程退出时，⾃ 动释放线程资源。
假如主线程不想再关心新线程，而是当新线程竣事的时候，让他本身释放？？

2. 设置新线程为分离状态
3. 技术层面:  线程默认是需要被等待的，joinable。如果不想让主线程等待新线程
4. 想让新线程结束之后，自己退出，设置为分离状态(!joinable or detach)  // todo
5. 理解层面：线程分离，主分离新，新把自己分离。
6. 分离的线程，依旧在进程的地址空间中，进程的所有资源，被分离的线程，依旧可以访问，可以操作。
7. 主不等待新线程。
8. 分离操作
9. 如果线程被设置为分离状态，不需要进行join，join会失败！！

复制代码

主线程设置分离

2. #include<iostream>
3. #include<unistd.h>
4. #include<pthread.h>
5. #include <cstring>
7. using namespace std;
9. void* routine(void* arg){
10.     string name = static_cast<const char*>(arg);
11.     int cnt = 5;
12.     while(cnt--)
13.     {
14.         cout<<"我是子线程，名字："<<name<<endl;
15.         sleep(1);
16.     }
17. }
19. int main(){
20.     pthread_t tid;
21.     pthread_create(&tid,nullptr,routine,(void*)"thread-1");
22.     //线程分离
23.     pthread_detach(tid);
24.     int cnt = 5;
25.     while(cnt--){
26.         cout<<"我是主线程"<<endl;
27.         sleep(1);
28.     }
29.     int n = pthread_join(tid,nullptr);
30.    
31.     if(n!=0){
32.         cout<<"pthread_join error"<<endl;
33.     }else{
34.         cout<<"pthread_join success"<<endl;
35.     }
36. }

复制代码

 一个被分离的历程，调用join会失败。
pthread_join()失败，就会返回0。
线程本身设置分离

2. #include<iostream>
3. #include<unistd.h>
4. #include<pthread.h>
5. #include <cstring>
7. using namespace std;
9. void* routine(void* arg){
10.     pthread_detach(pthread_self());
11.     string name = static_cast<const char*>(arg);
12.     int cnt = 5;
13.     while(cnt--)
14.     {
15.         cout<<"我是子线程，名字："<<name<<endl;
16.         sleep(1);
17.     }
18.     return nullptr;
19. }
21. int main(){
22.     pthread_t tid;
23.     pthread_create(&tid,nullptr,routine,(void*)"thread-1");
24.    
25.     int cnt = 5;
26.     while(cnt--){
27.         cout<<"我是主线程"<<endl;
28.         sleep(1);
29.     }
30.     int n = pthread_join(tid,nullptr);
31.    
32.     if(n!=0){
33.         cout<<"pthread_join error"<<endl;
34.     }else{
35.         cout<<"pthread_join success"<<endl;
36.     }
37. }

复制代码

 

创建多线程

2. #include <iostream>
3. #include <string>
4. #include <vector>
5. #include <unistd.h>
6. #include <pthread.h>
7. #include <cstdio>
8. #include <cstring>
10. 创建多线程
12. const int num = 10;
14. void *routine(void *args)
15. {
16.      sleep(1);
17.      std::string name = static_cast<const char *>(args);
18.      delete (char*)args;
20.      int cnt = 5;
21.      while (cnt--)
22.      {
23.          std::cout << "new线程名字: " << name << std::endl;
24.          sleep(1);
25.      }
26.      return nullptr;
27. }
29. int main()
30. {
31.      // char id[64];多执行流访问同一份资源，有危险。
32.      std::vector<pthread_t> tids;
33.      for (int i = 0; i < num; i++)
34.      {
35.          pthread_t tid;
36.          // bug??
37.          char *id = new char[64];//需要这么创建
38.          snprintf(id, 64, "thread-%d", i);
39.          int n = pthread_create(&tid, nullptr, routine, id);
40.          if (n == 0)
41.              tids.push_back(tid);
42.          else
43.              continue;
44.      }
46.      for (int i = 0; i < num; i++)
47.      {
48.          // 一个一个的等待
49.          int n = pthread_join(tids[i], nullptr);
50.          if (n == 0)
51.          {
52.              std::cout << "等待新线程成功" << std::endl;
53.          }
54.      }
56.      return 0;
57. }

复制代码

 监控：while :; do ps -aL | head -1 && ps -aL | grep thread; sleep 1; done
注意点： 

（1）
多执行流访问同一份资源，有危险。 

2. char id[64];多执行流访问同一份资源，有危险

复制代码

很大概率会引起，数据修改没导致结果不精确
（2） 为每一个线程本身创建一个，制止
多执行流访问同一份资源

2. 多执行流访问同一份资源

复制代码

 
线程ID及历程地址空间布局

2. • pthread_create函数会产⽣⼀个线程ID，存放在第⼀个参数指向的地址中。
3. 该线程ID和前⾯说的 线程ID不是⼀回事。
5. • 前⾯讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，
6. 是操作系统调度器的最⼩单位， 所以需要⼀个数值来唯⼀表⽰该线程。
8. • pthread_create函数第⼀个参数指向⼀个虚拟内存单元，
9. 该内存单元的地址即为新创建线程的线 程ID，属于NPTL线程库的范畴。
10. 线程库的后续操作，就是根据该线程ID来操作线程的。
12. • 线程库NPTL提供了pthread_self函数，可以获得线程⾃⾝的ID：

复制代码

动态库的链接类比：pthread库的链接 

过程：

磁盘内里的库文件，加载到物理内存内里，在把物理内存内里的库文件映射到mmap动态映射区域，大概可以叫做共享区。
如许历程本身的代码就可以访问到pthread库的内部函数大概数据
在库中对线程的管理： 

线程的概念是在库中维护的，在库内，就肯定会存在多个被创建好的线程，库要不要管理线程呢？要！
先形貌，在构造！！
创建线程形貌符

mmap内里对线程的管理

2. mmap:动态映射区域
3. TCB：线程的属性
4. 线程局部存储：暂时未知
5. 线程栈：暂时未知
6. 创建的返回值：
7. pthread_t tid:线程在库中，对应的管理快的虚拟地址。
9. 线程函数运行完，返回值，管理快还存在，
10. 所以线程需要join,
11. join通过tid拿到线程管理快返回信息后，把管理快释放掉

复制代码

（1）在一个线程中，运行完一个函数，那么，线程就会返回一个void*的值，*ret，但是管理线程的管理快并不会由于函数的实行完而消散，这里就会造成内存走漏，以是我们必要pthread_join，来获取返回值，而且释放管理块的空间
（2）pthread_join工作流程：利用join，就可以得到该线程的返回值，*ret,然后释放管理块的空间，join的参数，tid拿到管理快的起始假造地址，就可以访问该管理快，&ret则用来吸收返回值
（3） join:为什么要用二级指针来担当线程的返回值？？？便于修改值。单传不可修改值。

一个线程是怎么被创建的？？？ 

线程的一部门概念一部门在库内里实现：
pthread_create（&tid）创建线程时，起首会在pthread库内里创建一个线程的布局体struct_pthread（线程管理块）然后把id,返回给传入的tid,作为线程在pthread库的假造地址，后序好对线程举行操纵。
一部门在PCB内里实现：
在内核中创建轻量级历程，通过clone来举行实现。（可以在看一遍，做更深了解）
例子：
我叫张三打饭
我是线程，维护信息（线程管理块）
张三给我打饭，根据信息给我打饭，张三是轻量级历程，去给我实行
总结： 

 

ID:线程控制块的起始地址
返回值：线程实行完，的返回值，被join回收
分离：joinable = 0线程分离
joinable!=0,线程不分离
joinable线程标记位