【Linux】：封装线程

朋友们、伙计们，我们又见面了，本期来给大家带来封装线程相关的知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！
  
  C 语 言 专 栏：C语言：从入门到醒目
  数据结构专栏：数据结构
  个  人  主  页 ：stackY、
  C + + 专 栏   ：C++
  Linux 专 栏  ：Linux
  

​ 

目录

弁言：
1. 基础框架 
1.1 初步Start接口
1.2 修正后的Start接口
2. Join接口
 2.1 初步测试
3. 添加模版
4. 全部代码

---

弁言：

   我们想要通过封装原生线程库的方式来实现一个雷同于C++11里面的线程库，这里只是为了来更沉入的学习原生线程库，实现一些基础的功能即可；
    我们创建一个mian.cc文件用于测试线程逻辑；
  Thread.hpp紧张用于封装线程；
  Makefile紧张实现主动化代码构建。
  

​
  1. 基础框架 

   

• 我们想要封装的线程需要有对应的线程id、线程名、该线程是否运行以及线程所要执行的任务；
  
• 线程所需要执行的任务我们需要用函数包装器（functional）
  
• 我们想要实现的方法有一个让线程启动起来的方法，还需要有一个等待线程的方法；
  
• 后面根据需要添加对应的成员和方法。
  

  Thread.hpp：
  

先将基础框架搭建出来，后面再慢慢补充所需要的接口以及代码。
  1.1 初步Start接口

   在Start接口就是用来启动线程，那么在接口设计中就需要先创建进程，在对应的线程执行方法中执行我们预先设计好的func；
  

​
  

​
    这里就需要留意一下线程封装时的细节，我们先来看一下创建线程的接口具体传递的参数：
  

​
  我们设置的线程执行方法函数的参数只有一个参数，但是由于我们自己设置的ThreadRoutine函数是类内函数，那么类内函数会默认自己带一个this指针，以是这于原始函数设计接口不符，以是我们需要将该函数设置为静态成员函数，然后我们将this指针传递给他，然后通过this指针来调用我们预设的func；
  1.2 修正后的Start接口

   

  2. Join接口

   在实现Join之前我们可以设置一个检察线程是否运行的接口以及获取线程名的接口，方便后面的测试；
  在等待线程这里我们直接利用原生线程库的接口：
  

​
  我们目前不关心等待的效果；
  

   2.1 初步测试

   上面的代码算是一份非常简朴的线程封装代码，那么接下来我们利用main.cc来利用一下我们封装的线程库，由于我们将线程对象化了，以是我们就可以用容器来生存我们的线程，这其实就是一种“先描述，再构造”的过程。

1. #include <iostream>
2. #include <unistd.h>
3. #include <string>
4. #include <vector>
6. #include "Thread.hpp"
7. // 设置线程名
8. std::string GetThreadName()
9. {
10.     static int num = 1;
11.     char buffer[64];
12.     snprintf(buffer, sizeof(buffer), "Thread-%d", num++);
13.     return buffer;
14. }
16. void Print()
17. {
18.     while(1)
19.     {
20.         std::cout << "hello thread" << std::endl;
21.         sleep(1);
22.     }
23. }
25. int main()
26. {
27.     std::vector<Thread> threads;
28.     int num = 5;
29.     // 创建
30.     for(int i = 0; i< num; i++)
31.     {
32.         threads.push_back(Thread(GetThreadName(),Print));
33.     }
34.     for (auto &t : threads)
35.     {
36.         std::cout << t.ThreadName() << ", is running: " << t.IsRunning() << std::endl;
37.     }
38.     // 启动
39.     for (auto &t : threads)
40.     {
41.         t.Start();
42.     }
44.     for (auto &t : threads)
45.     {
46.         std::cout << t.ThreadName() << ", is running: " << t.IsRunning() << std::endl;
47.     }
48.     // Join
49.     for (auto &t : threads)
50.     {
51.         t.Join();
52.     }
53.     return 0;
54. }

复制代码

  3. 添加模版

   我们想给我们的线程传递参数，以是我们需要添加模版；
  整体代码：

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include <functional>
5. #include <pthread.h>
7. template <class T>
8. using func_t = std::function<void(T)>; // 任务
10. template <class T>
11. class Thread
12. {
13. public:
14.     Thread(const std::string &threadname, func_t<T> func, T data)
15.         : _tid(0), _thread_name(threadname), _isrunning(false), _func(func), _data(data)
16.     {
17.     }
18.     // 执行方法
19.     static void* ThreadRoutine(void *args)
20.     {
21.         Thread *ts = static_cast<Thread *>(args);
22.         ts->_func(ts->_data);
23.         return nullptr;
24.     }
25.     // 启动
26.     bool Start()
27.     {
28.         int n = pthread_create(&_tid, nullptr, ThreadRoutine, this); // 将this指针传递给ThreadRoutine
29.         if(n == 0)
30.         {
31.             _isrunning = true;
32.             return true;
33.         }
34.         else return false;
35.     }
36.     // 等待
37.     bool Join()
38.     {
39.         if (!_isrunning)
40.             return false;
41.         int n = pthread_join(_tid, nullptr);
42.         if (n == 0)
43.         {
44.             return true;
45.         }
46.         return false;
47.     }
48.     bool IsRunning()
49.     {
50.         return _isrunning;
51.     }
52.     std::string ThreadName()
53.     {
54.         return _thread_name;
55.     }
56.     ~Thread() {}
58. private:
59.     pthread_t _tid;           // 线程id
60.     std::string _thread_name; // 线程名
61.     bool _isrunning;          // 线程是否运行
62.     func_t<T> _func;             // 线程所执行任务
63.     T _data;                   // 传递数据类型
64. };

复制代码

  4. 全部代码

   Makefile

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

复制代码

main.cc

1. #include <iostream>
2. #include <unistd.h>
3. #include <string>
4. #include <vector>
6. #include "Thread.hpp"
7. // 设置线程名
8. std::string GetThreadName()
9. {
10.     static int num = 1;
11.     char buffer[64];
12.     snprintf(buffer, sizeof(buffer), "Thread-%d", num++);
13.     return buffer;
14. }
16. void Print(int num)
17. {
18.     while(num--)
19.     {
20.         std::cout << "hello thread num :" << num << std::endl;
21.         sleep(1);
22.     }
23. }
25. int main()
26. {
27.     Thread<int> t(GetThreadName(), Print, 5);
28.     t.Start();
29.     t.Join();
31.     // std::vector<Thread> threads;
32.     // int num = 5;
33.     // // 创建
34.     // for(int i = 0; i< num; i++)
35.     // {
36.     //     threads.push_back(Thread(GetThreadName(),Print));
37.     // }
38.     // for (auto &t : threads)
39.     // {
40.     //     std::cout << t.ThreadName() << ", is running: " << t.IsRunning() << std::endl;
41.     // }
42.     // // 启动
43.     // for (auto &t : threads)
44.     // {
45.     //     t.Start();
46.     // }
48.     // for (auto &t : threads)
49.     // {
50.     //     std::cout << t.ThreadName() << ", is running: " << t.IsRunning() << std::endl;
51.     // }
52.     // // Join
53.     // for (auto &t : threads)
54.     // {
55.     //     t.Join();
56.     // }
57.     // Thread ts(Printf, GetThreadName());
58.     // std::cout << "is thread running? " << ts.IsRunning() << std::endl;
59.     // ts.Start();
60.     // std::cout << "is thread running? " << ts.IsRunning() << std::endl;
61.     // ts.Join();
62.     return 0;
63. }

复制代码

Thread.hpp

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include <functional>
5. #include <pthread.h>
7. template <class T>
8. using func_t = std::function<void(T)>; // 任务
10. template <class T>
11. class Thread
12. {
13. public:
14.     Thread(const std::string &threadname, func_t<T> func, T data)
15.         : _tid(0), _thread_name(threadname), _isrunning(false), _func(func), _data(data)
16.     {
17.     }
18.     // 执行方法
19.     static void* ThreadRoutine(void *args)
20.     {
21.         Thread *ts = static_cast<Thread *>(args);
22.         ts->_func(ts->_data);
23.         return nullptr;
24.     }
25.     // 启动
26.     bool Start()
27.     {
28.         int n = pthread_create(&_tid, nullptr, ThreadRoutine, this); // 将this指针传递给ThreadRoutine
29.         if(n == 0)
30.         {
31.             _isrunning = true;
32.             return true;
33.         }
34.         else return false;
35.     }
36.     // 等待
37.     bool Join()
38.     {
39.         if (!_isrunning)
40.             return false;
41.         int n = pthread_join(_tid, nullptr);
42.         if (n == 0)
43.         {
44.             return true;
45.         }
46.         return false;
47.     }
48.     bool IsRunning()
49.     {
50.         return _isrunning;
51.     }
52.     std::string ThreadName()
53.     {
54.         return _thread_name;
55.     }
56.     ~Thread() {}
58. private:
59.     pthread_t _tid;           // 线程id
60.     std::string _thread_name; // 线程名
61.     bool _isrunning;          // 线程是否运行
62.     func_t<T> _func;             // 线程所执行任务
63.     T _data;                   // 传递数据类型
64. };

复制代码

  

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