一个简单的linux线程池

http://blog.csdn.net/wzjking0929/article/details/20312675

线程池：简单地说，线程池 就是预先创建好一批线程，方便、快速地处理收到的业务。比起传统的到来一个任务，即时创建一个线程来处理，节省了线程的创建和回收的开销，响应更快，效率更高。

 

在linux中，使用的是posix线程库，首先介绍几个常用的函数：

1 线程的创建和取消函数

pthread_create

创建线程

pthread_join

合并线程

pthread_cancel

取消线程

2 线程同步函数

pthread_mutex_lock

pthread_mutex_unlock

pthread_cond_signal

pthread_cond_wait

 

关于函数的详细说明，参考man手册

 

线程池的实现：

线程池的实现主要分为三部分，线程的创建、添加任务到线程池中、工作线程从任务队列中取出任务进行处理。

主要有两个类来实现，CTask,CThreadPool

/**
执行任务的类，设置任务数据并执行
**/

C代码  收藏代码
  1. class CTask  
  2. {  
  3. protected:  
  4.  string m_strTaskName;  //任务的名称  
  5.  void* m_ptrData;       //要执行的任务的具体数据  
  6. public:  
  7.  CTask(){}  
  8.  CTask(string taskName)  
  9.  {  
  10.   this->m_strTaskName = taskName;  
  11.   m_ptrData = NULL;  
  12.  }  
  13.  virtual int Run()= 0;  
  14.  void SetData(void* data);    //设置任务数据  
  15. };  

 

任务类是个虚类，所有的任务要从CTask类中继承 ，实现run接口，run接口中需要实现的就是具体解析任务的逻辑。m_ptrData是指向任务数据的指针，可以是简单数据类型，也可以是自定义的复杂数据类型。

 

线程池类

/**
线程池
**/

Java代码  收藏代码
  1. class CThreadPool  
  2. {  
  3. private:  
  4.  vector<CTask*> m_vecTaskList;         //任务列表  
  5.  int m_iThreadNum;                            //线程池中启动的线程数             
  6.  static vector<pthread_t> m_vecIdleThread;   //当前空闲的线程集合  
  7.  static vector<pthread_t> m_vecBusyThread;   //当前正在执行的线程集合  
  8.  static pthread_mutex_t m_pthreadMutex;    //线程同步锁  
  9.  static pthread_cond_t m_pthreadCond;    //线程同步的条件变量  
  10. protected:  
  11.  static void* ThreadFunc(void * threadData); //新线程的线程函数  
  12.  static int MoveToIdle(pthread_t tid);   //线程执行结束后，把自己放入到空闲线程中  
  13.  static int MoveToBusy(pthread_t tid);   //移入到忙碌线程中去  
  14.  int Create();          //创建所有的线程  
  15. public:  
  16.  CThreadPool(int threadNum);  
  17.  int AddTask(CTask *task);      //把任务添加到线程池中  
  18.  int StopAll();  
  19. };  

 

当线程池对象创建后，启动一批线程，并把所有的线程放入空闲列表中，当有任务到达时，某一个线程取出任务并进行处理。

线程之间的同步用线程锁和条件变量。

这个类的对外接口有两个：

AddTask函数把任务添加到线程池的任务列表中，并通知线程进行处理。当任务到到时，把任务放入m_vecTaskList任务列表中，并用pthread_cond_signal唤醒一个线程进行处理。

StopAll函数停止所有的线程

 

Cpp代码  收藏代码
  1. ************************************************  
  2.   
  3. 代码:  
  4.   
  5. ××××××××××××××××××××CThread.h  
  6.   
  7.    
  8.   
  9. #ifndef __CTHREAD  
  10. #define __CTHREAD  
  11. #include <vector>  
  12. #include <string>  
  13. #include <pthread.h>  
  14.   
  15. using namespace std;  
  16.   
  17. /** 
  18. 执行任务的类，设置任务数据并执行 
  19. **/  
  20. class CTask  
  21. {  
  22. protected:  
  23.  string m_strTaskName;  //任务的名称  
  24.  void* m_ptrData;       //要执行的任务的具体数据  
  25. public:  
  26.  CTask(){}  
  27.  CTask(string taskName)  
  28.  {  
  29.   this->m_strTaskName = taskName;  
  30.   m_ptrData = NULL;  
  31.  }  
  32.  virtual int Run()= 0;  
  33.  void SetData(void* data);    //设置任务数据  
  34. };  
  35.   
  36. /** 
  37. 线程池 
  38. **/  
  39. class CThreadPool  
  40. {  
  41. private:  
  42.  vector<CTask*> m_vecTaskList;         //任务列表  
  43.  int m_iThreadNum;                            //线程池中启动的线程数             
  44.  static vector<pthread_t> m_vecIdleThread;   //当前空闲的线程集合  
  45.  static vector<pthread_t> m_vecBusyThread;   //当前正在执行的线程集合  
  46.  static pthread_mutex_t m_pthreadMutex;    //线程同步锁  
  47.  static pthread_cond_t m_pthreadCond;    //线程同步的条件变量  
  48. protected:  
  49.  static void* ThreadFunc(void * threadData); //新线程的线程函数  
  50.  static int MoveToIdle(pthread_t tid);   //线程执行结束后，把自己放入到空闲线程中  
  51.  static int MoveToBusy(pthread_t tid);   //移入到忙碌线程中去  
  52.  int Create();          //创建所有的线程  
  53. public:  
  54.  CThreadPool(int threadNum);  
  55.  int AddTask(CTask *task);      //把任务添加到线程池中  
  56.  int StopAll();  
  57. };  
  58.   
  59. #endif  
  60.   
  61.    
  62.   
  63.    
  64.   
  65.    
  66.   
  67. 类的实现为：  
  68.   
  69. ××××××××××××××××××××CThread.cpp  
  70.   
  71.    
  72.   
  73. #include "CThread.h"  
  74. #include <string>  
  75. #include <iostream>  
  76.   
  77. using namespace std;  
  78.   
  79. void CTask::SetData(void * data)  
  80. {  
  81.  m_ptrData = data;  
  82. }  
  83.   
  84. vector<pthread_t> CThreadPool::m_vecBusyThread;  
  85. vector<pthread_t> CThreadPool::m_vecIdleThread;  
  86. pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;  
  87. pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER;  
  88.   
  89. CThreadPool::CThreadPool(int threadNum)  
  90. {  
  91.  this->m_iThreadNum = threadNum;  
  92.  Create();  
  93. }  
  94. int CThreadPool::MoveToIdle(pthread_t tid)  
  95. {  
  96.  vector<pthread_t>::iterator busyIter = m_vecBusyThread.begin();  
  97.  while(busyIter != m_vecBusyThread.end())  
  98.  {  
  99.   if(tid == *busyIter)  
  100.   {  
  101.    break;  
  102.   }  
  103.   busyIter++;  
  104.  }  
  105.  m_vecBusyThread.erase(busyIter);  
  106.  m_vecIdleThread.push_back(tid);  
  107.  return 0;  
  108. }  
  109.   
  110. int CThreadPool::MoveToBusy(pthread_t tid)  
  111. {  
  112.  vector<pthread_t>::iterator idleIter = m_vecIdleThread.begin();  
  113.  while(idleIter != m_vecIdleThread.end())  
  114.  {  
  115.   if(tid == *idleIter)  
  116.   {  
  117.    break;  
  118.   }  
  119.   idleIter++;  
  120.  }  
  121.  m_vecIdleThread.erase(idleIter);  
  122.  m_vecBusyThread.push_back(tid);  
  123.  return 0;  
  124. }  
  125. void* CThreadPool::ThreadFunc(void * threadData)  
  126. {  
  127.  pthread_t tid = pthread_self();  
  128.  while(1)  
  129.  {  
  130.   pthread_mutex_lock(&m_pthreadMutex);  
  131.   pthread_cond_wait(&m_pthreadCond,&m_pthreadMutex);  
  132.   cout << "tid:" << tid << " run" << endl;  
  133.   //get task  
  134.   vector<CTask*>* taskList = (vector<CTask*>*)threadData;  
  135.   vector<CTask*>::iterator iter = taskList->begin();  
  136.   while(iter != taskList->end())  
  137.   {  
  138.      
  139.    MoveToBusy(tid);  
  140.    break;  
  141.   }  
  142.   CTask* task = *iter;  
  143.   taskList->erase(iter);  
  144.   pthread_mutex_unlock(&m_pthreadMutex);  
  145.   cout << "idel thread number:" << CThreadPool::m_vecIdleThread.size() << endl;  
  146.   cout << "busy thread number:" << CThreadPool::m_vecBusyThread.size() << endl;  
  147.   //cout << "task to be run:" << taskList->size() << endl;  
  148.   task->Run();  
  149.     
  150.   //cout << "CThread::thread work" << endl;  
  151.   cout << "tid:" << tid << " idle" << endl;  
  152.     
  153.  }  
  154.  return (void*)0;  
  155. }  
  156.   
  157. int CThreadPool::AddTask(CTask *task)  
  158. {  
  159.  this->m_vecTaskList.push_back(task);  
  160.  pthread_cond_signal(&m_pthreadCond);  
  161.  return 0;  
  162. }  
  163. int CThreadPool::Create()  
  164. {  
  165.  for(int i = 0; i < m_iThreadNum;i++)  
  166.  {  
  167.   pthread_t tid = 0;  
  168.   pthread_create(&tid,NULL,ThreadFunc,&m_vecTaskList);  
  169.   m_vecIdleThread.push_back(tid);  
  170.  }  
  171.  return 0;  
  172. }  
  173.   
  174. int CThreadPool::StopAll()  
  175. {  
  176.  vector<pthread_t>::iterator iter = m_vecIdleThread.begin();  
  177.  while(iter != m_vecIdleThread.end())  
  178.  {  
  179.   pthread_cancel(*iter);  
  180.   pthread_join(*iter,NULL);  
  181.   iter++;  
  182.  }  
  183.   
  184.  iter = m_vecBusyThread.begin();  
  185.  while(iter != m_vecBusyThread.end())  
  186.  {  
  187.   pthread_cancel(*iter);  
  188.   pthread_join(*iter,NULL);  
  189.   iter++;  
  190.  }  
  191.    
  192.  return 0;  
  193. }  
  194.   
  195. 简单示例：  
  196.   
  197. ××××××××test.cpp  
  198.   
  199. #include "CThread.h"  
  200. #include <iostream>  
  201.   
  202. using namespace std;  
  203.   
  204. class CWorkTask: public CTask  
  205. {  
  206. public:  
  207.  CWorkTask()  
  208.  {}  
  209.  int Run()  
  210.  {  
  211.   cout << (char*)this->m_ptrData << endl;  
  212.   sleep(10);  
  213.   return 0;  
  214.  }  
  215. };  
  216. int main()  
  217. {  
  218.  CWorkTask taskObj;  
  219.  char szTmp[] = "this is the first thread running,haha success";  
  220.  taskObj.SetData((void*)szTmp);  
  221.  CThreadPool threadPool(10);  
  222.  for(int i = 0;i < 11;i++)  
  223.  {  
  224.   threadPool.AddTask(&taskObj);  
  225.  }  
  226.  while(1)  
  227.  {  
  228.   sleep(120);  
  229.  }  
  230.  return 0;  
  231. }  

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383823.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++制表符

C++制表符

制表符的转义字符为\t&#xff0c;一般情况下长度为8个空格&#xff0c;这里的8个指的是从上一个字符串的开头开始算&#xff0c;往后数8个&#xff0c;不够的话就补空格。 如果前面的字符串的长度大于等于8个&#xff0c;例如前面字符串的长度为x,那么就会补(8-x%8)个空格 例…
阅读更多...
C++派生类含有成员对象构造函数析构函数顺序

C++派生类含有成员对象构造函数析构函数顺序

参考博客&#xff1a;传送门1 当类中含有对象成员时&#xff1a; 类的构造函数要包含对成员对象的初始化&#xff0c;如果构造函数的成员初始化列表没有包含对成员对象的初始化&#xff0c;系统会自动调用成员对象的无参构造函数。顺序上&#xff1a;先调用成员对象的构造函数…
阅读更多...
链表逆序的原理及实例

链表逆序的原理及实例

http://blog.csdn.net/wangqing_12345/article/details/51757294 尾插法建立链表&#xff0c;带头结点设链表节点为typedef struct node {int data;struct node *next;}node_t, *pnode_t;要求将一带链表头List head的单向链表逆序。 分析&#xff1a; 1). 若链表为空或只有一个…
阅读更多...
C++关于虚基类、构造函数、析构函数、成员对象的两个程序浅析

C++关于虚基类、构造函数、析构函数、成员对象的两个程序浅析

预备博客&#xff1a; C虚继承中构造函数和析构函数顺序问题以及原理 C派生类含有成员对象构造函数析构函数顺序 C虚基类成员可见性 程序一如下&#xff1a; #include<iostream> using namespace std; class A { public:A(int a) :x(a) { cout << "A const…
阅读更多...
C++小型公司管理系统

C++小型公司管理系统

项目要求&#xff1a; 编写一个程序实现小型公司的人员信息管理系统。该公司雇员&#xff08;employee&#xff09;包括经理&#xff08;manager&#xff09;&#xff0c;技术人员&#xff08;technician&#xff09;、销售员&#xff08;salesman&#xff09;和销售部经理&…
阅读更多...
Linux网络编程“惊群”问题总结

Linux网络编程“惊群”问题总结

http://www.cnblogs.com/Anker/p/7071849.html 1、前言 我从事Linux系统下网络开发将近4年了&#xff0c;经常还是遇到一些问题&#xff0c;只是知其然而不知其所以然&#xff0c;有时候和其他人交流&#xff0c;搞得非常尴尬。如今计算机都是多核了&#xff0c;网络编程框架也…
阅读更多...
yfan.qiu linux硬链接与软链接

yfan.qiu linux硬链接与软链接

http://www.cnblogs.com/yfanqiu/archive/2012/06/11/2545556.html Linux 系统中有软链接和硬链接两种特殊的“文件”。 软链接可以看作是Windows中的快捷方式&#xff0c;可以让你快速链接到目标档案或目录。 硬链接则透过文件系统的inode来产生新档名&#xff0c;而不是产生…
阅读更多...
Linux C++线程池实例

Linux C++线程池实例

http://www.cnblogs.com/danxi/p/6636095.html 想做一个多线程服务器测试程序&#xff0c;因此参考了github的一些实例&#xff0c;然后自己动手写了类似的代码来加深理解。 目前了解的线程池实现有2种思路&#xff1a; 第一种&#xff1a; 主进程创建一定数量的线程&#xff0…
阅读更多...
Java编写简单的自定义异常类

Java编写简单的自定义异常类

除了系统中自己带的异常&#xff0c;我们也可以自己写一些简单的异常类来帮助我们处理问题。 所有的异常命名都是以Exception结尾&#xff0c;并且都是Exception的子类。 假设我们要编写一个人类的类&#xff0c;为了判断年龄的输入是否合法&#xff0c;我们编写了一个名为Il…
阅读更多...
【Java学习笔记九】多线程

【Java学习笔记九】多线程

程序&#xff1a;计算机指令的集合&#xff0c;它以文件的形式存储在磁盘上&#xff0c;是应用程序执行的蓝本。 进程&#xff1a;是一个程序在其自身的地址空间中的一次执行活动。进程是资源申请、调度和独立运行的单位&#xff0c;因此&#xff0c;它使用系统中的运行资源。而…
阅读更多...
【C++学习笔记四】运算符重载

【C++学习笔记四】运算符重载

当调用一个重载函数和重载运算符时&#xff0c;编译器通过把您所使用的参数类型和定义中的参数类型相比较&#xff0c;巨鼎选用最合适的定义。&#xff08;重载决策&#xff09; 重载运算符时带有特殊名称的函数&#xff0c;函数名是由关键字operator和其后要重载的运算符符号…
阅读更多...
C++（纯）虚函数重写时访问权限更改问题

C++（纯）虚函数重写时访问权限更改问题

我们知道在Java中是自动实现多态的&#xff0c;Java中规定重写的方法的访问权限不能缩小。那么在C中我们实现多态的时候是否可以更改&#xff08;缩小&#xff09;访问权限呢&#xff1f; 经过测试&#xff0c;得到的答案如下&#xff1a;如果用基类指针指向派生类对象实现多态…
阅读更多...
C++ — 智能指针的简单实现以及循环引用问题

C++ — 智能指针的简单实现以及循环引用问题

http://blog.csdn.net/dawn_sf/article/details/70168930 智能指针 ____________________________________________________ 今天我们来看一个高大上的东西&#xff0c;它叫智能指针。 哇这个名字听起来都智能的不得了&#xff0c;其实等你了解它你一定会有一点失望的。。。。因…
阅读更多...
C++开发者都应该使用的10个C++11特性

C++开发者都应该使用的10个C++11特性

http://blog.jobbole.com/44015/ 感谢冯上&#xff08;治不好你我就不是兽医 &#xff09;的热心翻译。如果其他朋友也有不错的原创或译文&#xff0c;可以尝试推荐给伯乐在线。】 在C11新标准中&#xff0c;语言本身和标准库都增加了很多新内容&#xff0c;本文只涉及了一些皮…
阅读更多...
shared_ptr的一些尴尬

shared_ptr的一些尴尬

http://blog.csdn.net/henan_lujun/article/details/8984543 shared_ptr在boost库中已经有多年了&#xff0c;C11又为其正名&#xff0c;把他引入了STL库&#xff0c;放到了std的下面&#xff0c;可见其颇有用武之地&#xff1b;但是shared_ptr是万能的吗&#xff1f;有没有什…
阅读更多...
C++转换构造函数和类型转换函数

C++转换构造函数和类型转换函数

参考博客&#xff1a;https://blog.csdn.net/feiyanaffection/article/details/79183340 隐式类型转换 如果不同类型的数据在一起操作的时候编译器会自动进行一个数据类型转换。例如常用的基本数据类型有如下类型转换关系&#xff1a; 转换构造函数 构造函数有且仅有一个参数…
阅读更多...
C++析构函数执行顺序

C++析构函数执行顺序

今天发现主程序中有多个对象时析构函数的执行顺序不是对象定义的顺序&#xff0c;而是对象定义顺序反过来。 思考了一下&#xff0c;结合之前继承、成员对象等的析构函数执行的顺序&#xff0c;我觉得析构函数执行的顺序为&#xff1a;构造函数的顺序反过来&#xff0c;可能是…
阅读更多...
c++写时拷贝1

c++写时拷贝1

http://blog.csdn.net/SuLiJuan66/article/details/48882303 Copy On Write Copy On Write(写时复制)使用了“引用计数”&#xff08;reference counting&#xff09;&#xff0c;会有一个变量用于保存引用的数量。当第一个类构造时&#xff0c;string的构造函数会根据传入的参…
阅读更多...
【Java学习笔记十】输入输出流

【Java学习笔记十】输入输出流

在Java.io包中提供了一系列用于处理输入/输出的流类。从功能上分为两类&#xff1a;输入流和输出流。从六结构上可分为&#xff1a;字节流&#xff08;以字节为处理单位&#xff09;和字符流&#xff08;以字符为处理单位&#xff09;。 字符是由字节组成。在Java中所有字符用…
阅读更多...
C++ 写时拷贝 2

C++ 写时拷贝 2

什么情况下会用到c中的拷贝构造函数】&#xff1a; 1&#xff09;用已经存在的同类的对象去构造出另一个新的对象 2&#xff09;当函数的形参是类的对象时&#xff0c;这时调用此函数&#xff0c;使用的是值的拷贝&#xff0c;也会调用拷贝构造函数 3&#xff09;当函数的返…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023