ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【Linux】一文带你了解C++中的多线程及其底层逻辑（thread、join、封装线程 [打印本页]
作者: 鼠扑    时间: 2025-1-25 06:08
标题: 【Linux】一文带你了解C++中的多线程及其底层逻辑（thread、join、封装线程
绪论​

每日鼓励：“不设限和自我肯定的心态：I can do all things。 — Stephen Curry”
    绪论​：
本章是线程的第三篇章，前两章带你了解了线程以及线程原生库中的操纵，本章主要结合前两章的根本，学习入门c++中的线程函数，了解其底层是什么，并且自己封装一个线程库来使用并巩固。
————————
早关注不迷路，话不多说安全带系好，发车啦（建议电脑观看）。
  站在语言角度再理解pthread库

C++中的多线程

  1. #include<unistd.h>
  2. #include<thread>
  3. #include<iostream>
  4. using namespace std;
  5. void myrun()
  6. {
  7.         while(true)
  8.         {
  9.                 cout << "i am thread" << endl;
  10.                 sleep(1);
  11.         }
  12. }
  14. int main()
  15. {
  16.         thread t(myrun);
  17.         t.join();
  18.        
  19.         return 0;
  20. }
复制代码
其中使用到的c++中封装的线程函数 thread、join，他们在编译的时候纵然看起来没有使用到原生线程库，但同样要加-lpthread，由于c++的多线程本质上就是封装了Linux（或Windows）的多线程，所以同样要包括pthread库。
也就是说：c++的库中的函数本质是对pthread库中体系调用函数（pthread_create）的封装（C++11内部的多线程，本质就是对原生线程库的封装）
线程属性的局部存储

含线程代码中的全局变量，在多个线程中是共享的。
代码：
  1. #include<iostream>
  2. #include<unistd.h>
  3. #include<cstdlib>
  4. #include<string>
  5. #include<pthread.h>
  6. #include <thread>
  8. using namespace std;
  10. int g_val = 100;
  12. void* ThreadRountine(void * args)
  13. {
  14.     string name = static_cast<const char *>(args);
  15.     while(true)
  16.     {
  17.         sleep(1);
  18.         cout << name <<": g_val:" << g_val << " &g_val: " << &g_val << endl;
  19.         g_val--;
  20.     }
  21.     return nullptr;
  22. }
  24. int main()
  25. {
  26.     pthread_t tid;
  27.     pthread_create(&tid,nullptr,ThreadRountine,(void*)"thread1");
  29.     while(true)
  30.     {
  31.         sleep(1);
  33.         cout << "main thread:"<<" g_val: " << g_val << " &g_val: " << &g_val << endl;
  34.     }
  36.     pthread_join(tid,nullptr);
  37. }
复制代码
此处线程中举行了递减操纵，发现外部主线程中同样也减少了：也就说明他们是共享的资源！

__thread

线程的局部存储：当给全局变量前加上__thread编译选项，这样就能实现线程的局部存储，每个线程都有自己的该全局变量。
留意点：__thread只能针对内置类型
  1. __thread int g_val = 100;
复制代码

上面的g_val就各自有一份了！
注：
线程中可以举行fork吗？虽然是可以在多线程程序中调用 fork()，但这种做法可能会导致程序的行为不稳定。尤其是如果你在多线程中使用 fork() 然后调用 exec() 来替换程序，可能会破坏多线程环境，由于 exec() 会终止全部线程。因此，除非非常必要，否则在多线程环境中使用 fork() 一般是不推荐的，特别是如果你计划举行进程替换。
模仿实现封装c++中的线程：

根据之前所知：c++的线程库底层本质就是封装了原始线程库的，所以自己也能通过面向对象的封装来自己实现，从而让自己更加了解
（很多细节请看解释）
thread.hpp：
  1. #pragma once
  3. #include<iostream>
  4. #include<string>
  5. #include<functional>
  6. #include<pthread.h>
  7. using namespace std;
  9. //typedef function<void()> func_t
  10. using func_t = function<void()>;//返回值void 参数为空;
  12. class Thread
  13. {
  14. public:
  15.     Thread(func_t func,const  string& name)
  16.     :_tid(0),_name(name),_isrunning(false),_func(func)
  17.     {}
  19. //因为在类内的函数默认是有this指针的这样就会导致pthread_create的threadrotine的类型不匹配而导致的无法传参
  20. //所以解决方法就是改成静态函数，但此时又不能使用成员变量了
  21. //所哟把参数args改成this传递进来！
  22.     static void *ThreadRotine(void* args)
  23.     {
  24.         Thread *ts = static_cast<Thread*>(args);//安全的类型转换
  26.         ts->_func();//执行函数
  27.         return nullptr;
  28.     }
  30.     bool Start()
  31.     {
  32.         int n = pthread_create(&_tid,nullptr,ThreadRotine,this);//创建线程
  33.         if(n == 0)
  34.         {
  35.             _isrunning = true;
  36.             return true;
  37.         }
  38.         else return false;
  39.     }  
  41.     string Threadname()
  42.     {
  43.         return _name;
  44.     }
  47.     bool Join()
  48.     {
  49.         if(!_isrunning) return true;
  50.         int n = pthread_join(_tid,nullptr);//等待线程
  51.         if(n==0)
  52.         {
  53.             _isrunning = false;
  54.             return true;
  55.         }
  56.         return false;
  58.     }
  60.     bool Isrunning()
  61.     {
  62.         return _isrunning;
  63.     }
  65.     ~Thread()
  66.     {}
  68. private:
  69.     string _name;
  70.     func_t _func;
  72.     pthread_t _tid;//创建自动形成
  73.     bool _isrunning;
  74. };
复制代码
main.cpp：
  1. #include<iostream>
  2. #include<thread>
  3. #include<cstdlib>
  4. #include "Thread.hpp"
  5. #include<unistd.h>
  6. #include<vector>
  7. using namespace std;
  9. string GetThreadname()
  10. {
  11.     static int number = 1;//本质就是全局变量
  12.     char name[64];
  13.     snprintf(name,sizeof(name),"thread-%d",number++);
  14.     return name;
  15. }
  17. void Print()
  18. {
  19.     while(true)
  20.     {
  21.         cout << "hello Linux"" << endl;
  22.         sleep(1);
  23.     }
  25. }
  26. int main()
  27. {
  28.     const int num = 5;
  29.     vector<Thread> threads;
  31.     for(int i = 0 ; i < num ;i++)
  32.     {
  33.         threads.push_back(Thread(Print,GetThreadname()));
  34.     }
  36. //此时并没有启动线程
  37.     for(auto &t : threads)
  38.     {
  39.         cout << t.Threadname() << " is,running：" << t.Isrunning() <<endl;//打印线程名称即运行状态
  40.     }
  43.     sleep(5);
  44.     for(auto &t:threads)
  45.     {
  46.         t.Start();
  47.     }
  49. //启动线程后
  50.     for(auto &t : threads)
  51.     {
  52.         cout << t.Threadname() << " is,running：" << t.Isrunning() <<endl;
  53.     }
  55.     for(auto &t : threads)
  56.     {
  57.         t.Join();
  58.     }
  60.     // Thread t(Print,GetThreadname());
  61.     // cout << "is thread running?: " << t.Isrunning() << endl;
  62.     // t.Start();
  64.     // cout << "is thread running?: " << t.Isrunning() << endl;
  66.     // t.Join();
  68.     return 0;
  69. }
复制代码
线程从未启动->启动->执行所对应的任务：

参加模板：写成能传参自界说函数和参数
  1. //thread.hpp
  2. #pragma once
  4. #include<iostream>
  5. #include<string>
  6. #include<functional>
  7. #include<pthread.h>
  8. using namespace std;
  10. //注意！！
  11. //此处的修改，因为带有模板所以后面用该类型变成fun_t<T>
  12. template<class T>
  13. using func_t = function<void(T)>;//返回值void 参数为;
  15. //加上模板，这个类型是给传进来的参数数据data的！
  16. template<class T>
  17. class Thread
  18. {
  19. public:
  20.     Thread(T data,func_t<T> func,const string& name)//此处从fun_t -> fun_t<T>
  21.     :_tid(0),_name(name),_isrunning(false),_func(func),_data(data)
  22.     {}
  24. //因为在类内的函数默认是有this指针的这样就会导致pthread_create的threadrotine的类型不匹配而导致的无法传参
  25. //所以解决方法就是改成静态函数，但此时又不能使用成员变量了，所哟把参数args改成this传递进来！
  26.     static void *ThreadRotine(void* args)
  27.     {
  28.         Thread *ts = static_cast<Thread*>(args);
  30.         ts->_func(ts->_data);
  31.         return nullptr;
  32.     }
  34.   //...和上面一样就省略了
  36. private:
  37.     string _name;
  38.     func_t<T> _func;//此处从fun_t -> fun_t<T>
  40.     pthread_t _tid;//创建自动形成
  41.     bool _isrunning;
  42.     T _data;
  43. };
  45. // ---------------------------------
  47. //main.cpp
  48. #include<iostream>
  49. #include<thread>
  50. #include<cstdlib>
  51. #include"Thread.hpp"
  52. #include<unistd.h>
  53. #include<vector>
  54. using namespace std;
  56. string GetThreadname()
  57. {
  58.     static int number = 1;//本质就是全局变量
  59.     char name[64];
  60.     snprintf(name,sizeof(name),"thread-%d",number++);
  61.     return name;
  62. }
  64. void Print(int num)
  65. {
  66.     while(num)
  67.     {
  68.         cout << "hello Linux: " << num-- <<  endl;
  69.         sleep(1);
  70.     }
  72. }
  73. int main()
  74. {
  75.     Thread<int> t(10,Print,GetThreadname());
  77.     t.Start();
  79.     t.Join();
  81.     return 0;
  82. }
复制代码
本章完。预知后事如何，暂听下回分解。
如果有任何题目欢迎讨论哈！
如果觉得这篇文章对你有所帮助的话点点赞吧！
连续更新大量Linux细致内容，早关注不迷路。
​

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4