Linux系统编程——线程池

http://blog.csdn.net/tennysonsky/article/details/46490099#

线程池基本原理

在传统服务器结构中，常是有一个总的监听线程监听有没有新的用户连接服务器，每当有一个新的用户进入，服务器就开启一个新的线程用户处理这 个用户的数据包。这个线程只服务于这个用户，当用户与服务器端关闭连接以后，服务器端销毁这个线程。（关于并发服务器更多详情，请看《并发服务器》）。


然而频繁地开辟与销毁线程极大地占用了系统的资源，而且在大量用户的情况下，系统为了开辟和销毁线程将浪费大量的时间和资源。线程池提供了一个解决外部大量用户与服务器有限资源的矛盾。


线程池和传统的一个用户对应一个线程的处理方法不同，它的基本思想就是在程序开始时就在内存中开辟一些线程，线程的数目是固定的，他们独自形成一个类，屏蔽了对外的操作，而服务器只需要将数据包交给线程池就可以了。当有新的客户请求到达时，不是新创建一个线程为其服务，而是从“池子”中选择一个空闲的线程为新的客户请求服务，服务完毕后，线程进入空闲线程池中。如果没有线程空闲的话，就将数据包暂时积累， 等待线程池内有线程空闲以后再进行处理。通过对多个任务重用已经存在的线程对象，降低了对线程对象创建和销毁的开销。当客户请求 时，线程对象已经存在，可以提高请求的响应时间，从而整体地提高了系统服务的表现。


线程池应用实例

一般来说实现一个线程池主要包括以下几个组成部分：

1）线程管理器：用于创建并管理线程池。


2）工作线程：线程池中实际执行任务的线程。在初始化线程时会预先创建好固定数目的线程在池中，这些初始化的线程一般处于空闲状态，一般不占用 CPU，占用较小的内存空间。


3）任务接口：每个任务必须实现的接口，当线程池的任务队列中有可执行任务时，被空闲的工作线程调去执行（线程的闲与忙是通过互斥量实现的），把任务抽象出来形成接口，可以做到线程池与具体的任务无关。


4）任务队列：用来存放没有处理的任务，提供一种缓冲机制，实现这种结构有好几种方法，常用的是队列，主要运用先进先出原理，另外一种是链表之类的数据结构，可以动态的为它分配内存空间，应用中比较灵活，此教程就是用到的链表。


什么时候需要创建线程池呢？简单的说，如果一个应用需要频繁的创建和销毁线程，而任务执行的时间又非常短，这样线程创建和销毁的带来的开销就不容忽视，这时也是线程池该出场的机会了。如果线程创建和销毁时间相比任务执行时间可以忽略不计，则没有必要使用线程池了。


线程池实现示例代码如下：


thread_pool.h 的示例代码：

[cpp] view plaincopy
  1. #ifndef __THREAD_POOL_H__  
  2. #define __THREAD_POOL_H__  
  3.   
  4. #include <pthread.h>  
  5.   
  6.  /********************************************************************* 
  7. * 任务回调函数，也可根据需要自行修改 
  8. *********************************************************************/  
  9. typedef void *(*pool_task_f)(void *arg);  
  10.   
  11. /********************************************************************* 
  12. * 任务句柄 
  13. *********************************************************************/  
  14. typedef struct _task{  
  15.     pool_task_f process;/*回调函数，任务运行时会调用此函数，注意也可声明成其它形式*/  
  16.     void *arg;     /*回调函数的参数*/  
  17.     struct _task *next;  
  18. }pool_task;  
  19.   
  20. /********************************************************************* 
  21. * 线程池句柄 
  22. *********************************************************************/  
  23. typedef struct  
  24. {  
  25.     pthread_t *threadid;        /* 线程号 */  
  26.     int threads_limit;          /* 线程池中允许的活动线程数目 */  
  27.     int destroy_flag;           /* 是否销毁线程池 , 0销毁，1不销毁*/  
  28.     pool_task *queue_head;      /* 链表结构，线程池中所有等待任务 */  
  29.     int task_in_queue;          /* 当前等待队列的任务数目 */  
  30.     pthread_mutex_t queue_lock; /* 锁 */  
  31.     pthread_cond_t queue_ready; /* 条件变量 */  
  32. }pool_t;  
  33.   
  34. /********************************************************************* 
  35. *功能:        初始化线程池结构体并创建线程 
  36. *参数:         
  37.             pool：线程池句柄 
  38.             threads_limit：线程池中线程的数量 
  39. *返回值:   无 
  40. *********************************************************************/  
  41. void pool_init(pool_t *pool, int threads_limit);  
  42.   
  43. /********************************************************************* 
  44. *功能:        销毁线程池，等待队列中的任务不会再被执行， 
  45.             但是正在运行的线程会一直,把任务运行完后再退出 
  46. *参数:        线程池句柄 
  47. *返回值:   成功：0，失败非0 
  48. *********************************************************************/  
  49. int pool_uninit(pool_t *pool);  
  50.   
  51. /********************************************************************* 
  52. *功能:        向线程池中添加一个任务 
  53. *参数:         
  54.             pool：线程池句柄 
  55.             process：任务处理函数 
  56.             arg：任务参数 
  57. *返回值:   0 
  58. *********************************************************************/  
  59. int pool_add_task(pool_t *pool, pool_task_f process, void *arg);  
  60.   
  61.   
  62. #endif  


thread_pool.c 的示例代码：
[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <pthread.h>  
  4. #include <assert.h>  
  5.   
  6. #include "thread_pool.h"  
  7.   
  8. static void *pool_thread_server(void *arg);  
  9.   
  10. /********************************************************************* 
  11. *功能:        初始化线程池结构体并创建线程 
  12. *参数:         
  13.             pool：线程池句柄 
  14.             threads_limit：线程池中线程的数量 
  15. *返回值:   无 
  16. *********************************************************************/  
  17. void pool_init(pool_t *pool, int threads_limit)  
  18. {  
  19.     pool->threads_limit = threads_limit;  
  20.     pool->queue_head = NULL;  
  21.     pool->task_in_queue = 0;  
  22.     pool->destroy_flag = 0;  
  23.     /*创建存放线程ID的空间*/  
  24.     pool->threadid = (pthread_t *)calloc(threads_limit, sizeof(pthread_t));  
  25.     int i = 0;  
  26.     /*初始化互斥锁和条件变量*/  
  27.     pthread_mutex_init(&(pool->queue_lock), NULL);  
  28.     pthread_cond_init(&(pool->queue_ready), NULL);  
  29.     /*循环创建threads_limit个线程*/  
  30.     for (i = 0; i < threads_limit; i++){  
  31.         pthread_create(&(pool->threadid[i]), NULL, pool_thread_server, pool);  
  32.     }  
  33.     return;  
  34. }  
  35.   
  36. /********************************************************************* 
  37. *功能:        销毁线程池，等待队列中的任务不会再被执行， 
  38.             但是正在运行的线程会一直,把任务运行完后再退出 
  39. *参数:        线程池句柄 
  40. *返回值:   成功：0，失败非0 
  41. *********************************************************************/  
  42. int pool_uninit(pool_t *pool)  
  43. {  
  44.     pool_task *head = NULL;  
  45.     int i;  
  46.       
  47.     pthread_mutex_lock(&(pool->queue_lock));  
  48.     if(pool->destroy_flag)/* 防止两次调用 */  
  49.         return -1;  
  50.     pool->destroy_flag = 1;  
  51.     pthread_mutex_unlock(&(pool->queue_lock));  
  52.     /* 唤醒所有等待线程，线程池要销毁了 */  
  53.     pthread_cond_broadcast(&(pool->queue_ready));  
  54.     /* 阻塞等待线程退出，否则就成僵尸了 */  
  55.     for (i = 0; i < pool->threads_limit; i++)  
  56.         pthread_join(pool->threadid[i], NULL);  
  57.     free(pool->threadid);  
  58.     /* 销毁等待队列 */  
  59.     pthread_mutex_lock(&(pool->queue_lock));  
  60.     while(pool->queue_head != NULL){  
  61.         head = pool->queue_head;  
  62.         pool->queue_head = pool->queue_head->next;  
  63.         free(head);  
  64.     }  
  65.     pthread_mutex_unlock(&(pool->queue_lock));  
  66.     /*条件变量和互斥量也别忘了销毁*/  
  67.     pthread_mutex_destroy(&(pool->queue_lock));  
  68.     pthread_cond_destroy(&(pool->queue_ready));  
  69.     return 0;  
  70. }  
  71.   
  72. /********************************************************************* 
  73. *功能:        向任务队列中添加一个任务 
  74. *参数:         
  75.             pool：线程池句柄 
  76.             process：任务处理函数 
  77.             arg：任务参数 
  78. *返回值:   无 
  79. *********************************************************************/  
  80. static void enqueue_task(pool_t *pool, pool_task_f process, void *arg)  
  81. {  
  82.     pool_task *task = NULL;  
  83.     pool_task *member = NULL;  
  84.       
  85.     pthread_mutex_lock(&(pool->queue_lock));  
  86.       
  87.     if(pool->task_in_queue >= pool->threads_limit){  
  88.         printf("task_in_queue > threads_limit!\n");  
  89.         pthread_mutex_unlock (&(pool->queue_lock));  
  90.         return;  
  91.     }  
  92.       
  93.     task = (pool_task *)calloc(1, sizeof(pool_task));  
  94.     assert(task != NULL);  
  95.     task->process = process;  
  96.     task->arg = arg;  
  97.     task->next = NULL;  
  98.     pool->task_in_queue++;  
  99.     member = pool->queue_head;  
  100.     if(member != NULL){  
  101.         while(member->next != NULL)  /* 将任务加入到任务链连的最后位置. */  
  102.             member = member->next;  
  103.         member->next = task;  
  104.     }else{  
  105.         pool->queue_head = task; /* 如果是第一个任务的话,就指向头 */  
  106.     }  
  107.     printf("\ttasks %d\n", pool->task_in_queue);  
  108.     /* 等待队列中有任务了，唤醒一个等待线程 */  
  109.     pthread_cond_signal (&(pool->queue_ready));  
  110.     pthread_mutex_unlock (&(pool->queue_lock));  
  111. }  
  112.   
  113. /********************************************************************* 
  114. *功能:        从任务队列中取出一个任务 
  115. *参数:        线程池句柄 
  116. *返回值:   任务句柄 
  117. *********************************************************************/  
  118. static pool_task *dequeue_task(pool_t *pool)  
  119. {  
  120.     pool_task *task = NULL;  
  121.       
  122.     pthread_mutex_lock(&(pool->queue_lock));  
  123.     /* 判断线程池是否要销毁了 */  
  124.     if(pool->destroy_flag){  
  125.         pthread_mutex_unlock(&(pool->queue_lock));  
  126.         printf("thread 0x%lx will be destroyed\n", pthread_self());  
  127.         pthread_exit(NULL);  
  128.     }  
  129.     /* 如果等待队列为0并且不销毁线程池，则处于阻塞状态 */  
  130.     if(pool->task_in_queue == 0){  
  131.         while((pool->task_in_queue == 0) && (!pool->destroy_flag)){  
  132.             printf("thread 0x%lx is waitting\n", pthread_self());  
  133.             /* 注意:pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁 */  
  134.             pthread_cond_wait(&(pool->queue_ready), &(pool->queue_lock));  
  135.         }  
  136.     }else{  
  137.         /* 等待队列长度减去1，并取出队列中的第一个元素 */  
  138.         pool->task_in_queue--;  
  139.         task = pool->queue_head;  
  140.         pool->queue_head = task->next;  
  141.         printf("thread 0x%lx received a task\n", pthread_self());  
  142.     }  
  143.     pthread_mutex_unlock(&(pool->queue_lock));  
  144.     return task;  
  145. }  
  146.   
  147. /********************************************************************* 
  148. *功能:        向线程池中添加一个任务 
  149. *参数:         
  150.             pool：线程池句柄 
  151.             process：任务处理函数 
  152.             arg：任务参数 
  153. *返回值:   0 
  154. *********************************************************************/  
  155. int pool_add_task(pool_t *pool, pool_task_f process, void *arg)  
  156. {  
  157.     enqueue_task(pool, process, arg);  
  158.     return 0;  
  159. }  
  160.   
  161. /********************************************************************* 
  162. *功能:        线程池服务程序 
  163. *参数:        略 
  164. *返回值:   略 
  165. *********************************************************************/  
  166. static void *pool_thread_server(void *arg)  
  167. {  
  168.     pool_t *pool = NULL;  
  169.       
  170.     pool = (pool_t *)arg;  
  171.     while(1){  
  172.         pool_task *task = NULL;  
  173.         task = dequeue_task(pool);  
  174.         /*调用回调函数，执行任务*/  
  175.         if(task != NULL){  
  176.             printf ("thread 0x%lx is busy\n", pthread_self());  
  177.             task->process(task->arg);  
  178.             free(task);  
  179.             task = NULL;  
  180.         }  
  181.     }  
  182.     /*这一句应该是不可达的*/  
  183.     pthread_exit(NULL);    
  184.     return NULL;  
  185. }  

下面是测试代码：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3.   
  4. #include "thread_pool.h"  
  5.   
  6. void *task_test(void *arg)  
  7. {  
  8.     printf("\t\tworking on task %d\n", (int)arg);  
  9.     sleep(1);           /*休息一秒，延长任务的执行时间*/  
  10.     return NULL;  
  11. }  
  12.   
  13. void thread_pool_demo(void)  
  14. {  
  15.     pool_t pool;  
  16.     int i = 0;  
  17.   
  18.     pool_init(&pool, 2);//初始化一个线程池，其中创建2个线程  
  19.     sleep(1);  
  20.     for(i = 0; i < 5; i++){  
  21.         sleep(1);  
  22.         pool_add_task(&pool, task_test, (void *)i);//添加一个任务  
  23.     }  
  24.     sleep(4);  
  25.   
  26.     pool_uninit(&pool);//删除线程池  
  27. }  
  28.   
  29. int main (int argc, char *argv[])  
  30. {    
  31.     thread_pool_demo();  
  32.     return 0;  
  33. }  

运行结果如下：




本教程示例代码下载请点此处。


参考资料：http://blog.csdn.net/hubi0952


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

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

相关文章

简单Linux C线程池

简单Linux C线程池

http://www.cnblogs.com/venow/archive/2012/11/22/2779667.html 大多数的网络服务器&#xff0c;包括Web服务器都具有一个特点&#xff0c;就是单位时间内必须处理数目巨大的连接请求&#xff0c;但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的&#xff1…
阅读更多...
IO多路复用之poll总结

IO多路复用之poll总结

http://www.cnblogs.com/Anker/p/3261006.html 1、基本知识 poll的机制与select类似&#xff0c;与select在本质上没有多大差别&#xff0c;管理多个描述符也是进行轮询&#xff0c;根据描述符的状态进行处理&#xff0c;但是poll没有最大文件描述符数量的限制。poll和select同…
阅读更多...
【C++学习笔记二】C++继承

【C++学习笔记二】C++继承

继承 继承允许我们一句另一个类来定义一个类&#xff0c;这使得继承和维护一个程序变得更加容易&#xff0c;也达到了重用代码功能和提高执行效率的效果。 一般格式为&#xff1a; class 派生类名 :访问修饰符 基类名{};其中访问修饰符是public protected private中的一个&a…
阅读更多...
处理大并发之二 对epoll的理解，epoll客户端服务端代码

处理大并发之二 对epoll的理解，epoll客户端服务端代码

http://blog.csdn.net/wzjking0929/article/details/51838370 序言&#xff1a; 该博客是一系列的博客&#xff0c;首先从最基础的epoll说起&#xff0c;然后研究libevent源码及使用方法&#xff0c;最后研究nginx和node.js&#xff0c;关于select,poll这里不做说明&#xff0c…
阅读更多...
C++基类指针指向派生类（指针）

C++基类指针指向派生类（指针）

我们常用基类指针指向派生类对象来实现多态性。 私有继承不允许基类指针指向派生类 基类指针只能访问到基类中含有的公有成员。 当用基类指针指向派生类对象在动态分配堆上内存的时候&#xff0c;析构函数必须是虚函数! 成员如果是数据成员的话访问的是基类的版本&#xff…
阅读更多...
一个简单的linux线程池

一个简单的linux线程池

http://blog.csdn.net/wzjking0929/article/details/20312675 线程池&#xff1a;简单地说&#xff0c;线程池 就是预先创建好一批线程&#xff0c;方便、快速地处理收到的业务。比起传统的到来一个任务&#xff0c;即时创建一个线程来处理&#xff0c;节省了线程的创建和回收的…
阅读更多...
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;本文只涉及了一些皮…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023