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，一经查实，立即删除！

相关文章

【Java学习笔记五】Java异常处理

【Java学习笔记五】Java异常处理

异常通常分为三类&#xff1a; 程序可控制的异常&#xff1a;一般是可预见的错误&#xff0c;不是致命的。例如&#xff1a;除数为0&#xff0c;数组下标越界。程序不可控制的的异常&#xff1a;这种异常往往是致命的&#xff0c;但是系统可以预见的。例如&#xff1a;系统栈溢…
阅读更多...
【C++学习笔记一】C++类和对象详解

【C++学习笔记一】C++类和对象详解

类定义是以关键字class开头&#xff0c;后面跟类的名称。主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。 类的对象的公共数据成员可以使用直接成员访问运算符.来访问。需要注意的是&#xff0c;私有的成员和受保护的成员不能直接使用成员访问运算符来访…
阅读更多...
C语言实现的简单的线程池

C语言实现的简单的线程池

http://www.linuxidc.com/Linux/2013-01/77619.htm 有时我们会需要大量线程来处理一些相互独立的任务&#xff0c;为了避免频繁的申请释放线程所带来的开销&#xff0c;我们可以使用线程池。下面是一个C语言实现的简单的线程池。 头文件&#xff1a; 1: #ifndef THREAD_POOL_H_…
阅读更多...
C++获取当前时间

C++获取当前时间

可以使用windowsAPI直接获取。 例如&#xff1a; #include<windows.h> #include<cstdio>using namespace std;int main() {SYSTEMTIME now;GetLocalTime(&now);printf("现在是%02d时%02d分%02d秒\n",now.wHour,now.wMinute,now.wSecond);printf(&…
阅读更多...
成员函数后面加上const的作用

成员函数后面加上const的作用

const表示成员函数不会修改类中的数据成员。 规则&#xff1a; 在类中被const 声明的函数只能访问const 函数&#xff0c;而非const 函数可以访问任意成员函数。在成员函数中不管数据是否具有const 属性&#xff0c;编译器检查的的是是否有修改&#xff08;赋值&#xff0c;自…
阅读更多...
简单Linux C线程池

简单Linux C线程池

http://www.cnblogs.com/venow/archive/2012/11/22/2779667.html 大多数的网络服务器&#xff0c;包括Web服务器都具有一个特点&#xff0c;就是单位时间内必须处理数目巨大的连接请求&#xff0c;但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的&#xff1…
阅读更多...
C++创建对象：栈和堆的区别

C++创建对象：栈和堆的区别

首先我们应该了解栈和堆的差别&#xff1a; 详细信息&#xff1a;传送门 栈相当于函数自带的存储空间&#xff0c;在windows下一般为2M,在Linux下一般为8M&#xff0c;存取速度稍微快一点。堆是系统的空间&#xff0c;相对较大&#xff0c;一般为2G&#xff0c;效率稍微慢一点…
阅读更多...
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…
阅读更多...
C++虚继承中构造函数和析构函数顺序问题以及原理

C++虚继承中构造函数和析构函数顺序问题以及原理

多重继承的问题&#xff1a;多个类B,C,…继承同一个类A导致如果X继承了B,C,…那么在X中将还有多个A中成员的拷贝&#xff0c;如果想要访问A中的成员如果不加名字空间将会导致二义性&#xff0c;这种拷贝大多是没有实际意义的&#xff0c;为了避免这种空间浪费&#xff0c;C有虚…
阅读更多...
一个简单的linux线程池

一个简单的linux线程池

http://blog.csdn.net/wzjking0929/article/details/20312675 线程池&#xff1a;简单地说&#xff0c;线程池 就是预先创建好一批线程&#xff0c;方便、快速地处理收到的业务。比起传统的到来一个任务&#xff0c;即时创建一个线程来处理&#xff0c;节省了线程的创建和回收的…
阅读更多...
【C++学习笔记三】C++多态、抽象（接口）

【C++学习笔记三】C++多态、抽象（接口）

当类之间存在多种层次结构&#xff0c;并且类之间通过继承关联时就会用到多态。 虚函数在子类中的覆盖版本和该函数在基类中的原始版本必须有相同的函数签名、函数名、形参名、常属性。如果返回值为非类类型&#xff0c;则必须相同&#xff0c;如果是类类型A的指针或者引用&am…
阅读更多...
C++重载和重写的条件以及重写后对基类函数的覆盖

C++重载和重写的条件以及重写后对基类函数的覆盖

重载&#xff1a;同一个类中名字相同&#xff0c;参数列表不同的方法构成重载函数&#xff0c;和返回值没有关系。这就意味着就算返回值不同&#xff0c;只要名字相同参数列表相同编译器还是会报错&#xff0c;觉得一函数被定义了两次。 重写&#xff1a;派生类中只要函数名字…
阅读更多...
C++静态成员和静态方法

C++静态成员和静态方法

在类中&#xff0c;静态成员可以实现多个对象之间共享数据&#xff0c;同时保证了安全性。静态数据对该类的所有对象是公有的&#xff0c;存储一处供所有对象使用。 注意&#xff1a; 静态成员定义时需要在前面加上关键字static静态成员必须初始化且必须在类外进行&#xff0…
阅读更多...
基于epoll的简单的http服务器

基于epoll的简单的http服务器

http://blog.csdn.net/fangjian1204/article/details/34415651 http服务器已经可以处理并发连接&#xff0c;支持多个客户端并发访问&#xff0c;每个连接可以持续读写数据&#xff0c;当然&#xff0c;这只是一个简单的学习例子&#xff0c;还有很多bug&#xff0c;发表出来只…
阅读更多...
C++单例模式简单实现

C++单例模式简单实现

有时候我们需要某个类只能被实例化一次&#xff0c;并且其他类都可以访问到这个类&#xff0c;就需要这种设计模式。 例如我们想要做个资源管理器&#xff0c;显然这个管理器只能有一个。 这种模式有很多实现方式&#xff0c;这里介绍最简单的一种&#xff0c;想要了解更多可…
阅读更多...
Linux C++ 实现线程池

Linux C++ 实现线程池

http://blog.csdn.net/qq_25425023/article/details/53914609 线程池中的线程&#xff0c;在任务队列为空的时候&#xff0c;等待任务的到来&#xff0c;任务队列中有任务时&#xff0c;则依次获取任务来执行&#xff0c;任务队列需要同步。 Linux线程同步有多种方法&#xff…
阅读更多...
C++制表符

C++制表符

制表符的转义字符为\t&#xff0c;一般情况下长度为8个空格&#xff0c;这里的8个指的是从上一个字符串的开头开始算&#xff0c;往后数8个&#xff0c;不够的话就补空格。 如果前面的字符串的长度大于等于8个&#xff0c;例如前面字符串的长度为x,那么就会补(8-x%8)个空格 例…
阅读更多...
最新文章

Copyright @ 2022~2023