程序博客网 > 关系数据库特征

linux下C语言使用线程池（附带编码）

来源：互联网 发布：关系数据库特征 编辑：程序博客网 时间：2024/05/17 03:31

本人也是学习，希望多多指正

使用一个东西，我们要明白为什么使用它，如何使用它，使用它能达到什么效果

在写本文章时，我也借鉴了网上的部分资源，因为是之前很早搜索到的资料无法追踪源头，所以在此不再写来源，谨感谢各位大神。

1 使用线程池的原因

通常使用多线程都是在需要的时候创建一个新的线程，然后执行任务，完成后退出。一般情况下是完全够满足我们的程序的。

但是当我们需要创建大量的线程，并且执行一个简单的任务之后销毁，比如：在web，email，db里面的一些应用，如彩铃，或者网络通信编程，或者云计算里面后台镜像处理的时候，我们的应用在任何时候都要准备面对数目巨大的连接请求，同时，这些请求执行的任务却又比较简单，占用的时间很少，这样我们可能就会处于不停的创建线程并销毁线程的状态。虽说比起进程的创建，线程的创建时间已经大大缩短，但是如果需要频繁的创建线程，并且每个线程所占用的处理时间又非常简短，则线程创建和销毁带给处理器的额外负担也是很可观的。

线程池的作用正是在这种情况下有效的降低频繁创建销毁线程所带来的额外开销。一般来说，线程池都是采用预创建的技术，在应用启动之初便预先创建一定数目的线程。应用在运行的过程中，需要时可以从这些线程所组成的线程池里申请分配一个空闲的线程，来执行一定的任务，任务完成后，并不是将线程销毁，而是将它返还给线程池，由线程池自行管理。如果线程池中预先分配的线程已经全部分配完毕，但此时又有新的任务请求，则线程池会动态的创建新的线程去适应这个请求。当然，有可能，某些时段应用并不需要执行很多的任务，导致了线程池中的线程大多处于空闲的状态，为了节省系统资源，线程池就需要动态的销毁其中的一部分空闲线程。因此，线程池都需要一个管理者，按照一定的要求去动态的维护其中线程的数目。

当然，如果线程创建和销毁时间相比任务执行时间可以忽略不计，则没有必要使用线程池了。


2 如何使用它

线程池会维护一个任务链表(每个CThread_worker结构就是一个任务)。
pool_init()函数预先创建好max_thread_num个线程，每个线程执thread_routine ()函数。该函数中

  1. while (pool->cur_queue_size == 0)
  2. {
  3. pthread_cond_wait (&(pool->queue_ready),&(pool->queue_lock));
  4. }
表示如果任务链表中没有任务，则该线程出于阻塞等待状态。否则从队列中取出任务并执行。

pool_add_worker()函数向线程池的任务链表中加入一个任务，加入后通过调用pthread_cond_signal (&(pool->queue_ready))唤醒一个出于阻塞状态的线程(如果有的话)。

pool_destroy ()函数用于销毁线程池，线程池任务链表中的任务不会再被执行，但是正在运行的线程会一直把任务运行完后再退出


3 使用它能达到的效果

实际上，创建太多的线程可能会导致由于过度使用系统资源而耗尽内存。为了防止资源不足，服务器应用程序可以采用线程池来限制同一时刻处理的线程数目。线程池不会占用主线程，也不会延迟后续请求的处理。一旦池中的某个线程完成任务，它将返回到等待线程队列中，等待被再次使用。这种重用使应用程序可以避免为每个任务创建新线程引起的资源和时间消耗。
4  代码实现
这是个比较简单的版本，如果想更好的话，需要再改进一年，推荐大家去网上找一下tinyftp的源码，里面有个thread pool的实现很完善很好。
[cpp] view plaincopyprint?
  1. <PRE class=cpp name="code">/*********************************************/  
  2. //   
  3. //          DATE:   2012-8-3   
  4. //          TIME:   下午2:42:21   
  5. //          author: sky   
  6. //          file:   simple_pool.c   
  7. //          todo:   TODO   
  8. //   
  9. /**********************************************/  
  10. #include <stdlib.h>   
  11. #include <stdio.h>   
  12. #include <unistd.h>   
  13. #include <pthread.h>   
  14. #include <assert.h>   
  15.   
  16. /* 
  17. *线程池里所有运行和等待的任务都是一个Thread_worker 
  18. *由于所有任务都在链表里，所以是一个链表结构 
  19. */  
  20. typedef struct worker  
  21. {  
  22.      /*回调函数，任务运行时会调用此函数，注意也可声明成其它形式*/  
  23.     void *(*process_interface)(void * arg);  
  24.     void *arg;  
  25.     struct worker * next;  
  26.   
  27. } Thread_worker;  
  28.   
  29. typedef struct  
  30. {  
  31.     pthread_mutex_t pool_mutex;  
  32.     pthread_cond_t pool_cond;  
  33.   
  34.     /*任务队列的头指针*/  
  35.     Thread_worker *worker_queue_head;  
  36.   
  37.     /*是否销毁线程池*/  
  38.     int is_destory;  
  39.     pthread_t * thread_id;  
  40.     int thread_max_num;  
  41.     int cur_queue_size;  
  42.   
  43. } Thread_pool;  
  44.   
  45. //此处声明了一个pool的全局变量   
  46. Thread_pool *pool = NULL;  
  47.   
  48. //////////////////////////////////   
  49. //   
  50. //function:pool_init   
  51. //arguments:thread_max_num   
  52. //TODO:初始化连接池   
  53. //   
  54. ///////////////////////////////////   
  55. void pool_init(int thread_max_num);  
  56.   
  57. //////////////////////////////////   
  58. //   
  59. //function:pool_add_worker   
  60. //arguments:void *(*process)(void *args), void *args   
  61. //TODO:添加任务   
  62. //   
  63. ///////////////////////////////////   
  64. int pool_add_worker(void *(*process)(void *args), void *args);  
  65.   
  66. void *thread_routine(void * args);  
  67.   
  68. //////////////////////////////////   
  69. //   
  70. //function:pool_destory   
  71. //arguments:   
  72. //TODO:销毁连接池   
  73. //   
  74. ///////////////////////////////////   
  75. int pool_destory();  
  76.   
  77. //////////////////////   
  78. //具体实现如下   
  79. ///////////////////////   
  80.   
  81. void pool_init(int thread_max_num)  
  82. {  
  83.     pool = (Thread_pool *) malloc(sizeof(Thread_pool));  
  84.   
  85.     pthread_mutex_init(&(pool->pool_mutex), NULL );  
  86.     pthread_cond_init(&(pool->pool_cond), NULL );  
  87.   
  88.     pool->is_destory = 0; //0代表不销毁   
  89.     pool->worker_queue_head = NULL;  
  90.     pool->thread_max_num = thread_max_num;  
  91.     pool->cur_queue_size = 0;  
  92.     pool->thread_id = (pthread_t *) malloc(sizeof(pthread_t) * thread_max_num);  
  93.     int i = 0;  
  94.     for (; i < thread_max_num; i++)  
  95.     {  
  96.         pthread_create(&(pool->thread_id[i]), NULL, thread_routine, NULL );  
  97.     }  
  98.   
  99. }  
  100.   
  101. void * thread_routine(void *args)  
  102. {  
  103.     printf("starting thread 0x%x\n", pthread_self());  
  104.     while (1)  
  105.     {  
  106.         /*如果等待队列为0并且不销毁线程池，则处于阻塞状态; 注意 
  107.          pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁*/  
  108.         pthread_mutex_lock(&(pool->pool_mutex));  
  109.         while (pool->cur_queue_size == 0 && !pool->is_destory)  
  110.         {  
  111.             printf("thread 0x%x is waiting\n", pthread_self());  
  112.             pthread_cond_wait(&(pool->pool_cond), &(pool->pool_mutex));  
  113.         }  
  114.           /*线程池要销毁了*/  
  115.         if (pool->is_destory)  
  116.         {  
  117.             pthread_mutex_unlock(&(pool->pool_mutex));  
  118.             printf("thread 0x%x will exit\n", pthread_self());  
  119.             pthread_exit(NULL );  
  120.         }  
  121.         printf("thread 0x%x is starting to work\n", pthread_self());  
  122.   
  123.         assert(pool->cur_queue_size!=0);  
  124.         assert(pool->worker_queue_head!=NULL);  
  125.   
  126.         pool->cur_queue_size--;  
  127.         Thread_worker *worker = pool->worker_queue_head;  
  128.         pool->worker_queue_head = worker->next;  
  129.         pthread_mutex_unlock(&(pool->pool_mutex));  
  130.         /*调用回调函数，执行任务*/  
  131.         (*(worker->process_interface))(worker->arg);  
  132.         free(worker);  
  133.         worker = NULL;  
  134.     }  
  135.     pthread_exit(NULL );  
  136. }  
  137.   
  138. int pool_add_worker(void *(*process)(void * args), void*args)  
  139. {  
  140.     Thread_worker *new_worker = (Thread_worker *) malloc(sizeof(Thread_worker));  
  141.     new_worker->process_interface = process;  
  142.     new_worker->arg = args;  
  143.     new_worker->next = NULL;  
  144.   
  145.       /*将任务加入到等待队列中*/  
  146.     pthread_mutex_lock(&(pool->pool_mutex));  
  147.     Thread_worker *member = pool->worker_queue_head;  
  148.     if (member != NULL )  
  149.     {  
  150.         while (member->next != NULL )  
  151.             member = member->next;  
  152.         member->next = new_worker;  
  153.     }  
  154.     else  
  155.     {  
  156.         pool->worker_queue_head = new_worker;  
  157.     }  
  158.     assert(pool->worker_queue_head!=NULL);  
  159.   
  160.     pool->cur_queue_size++;  
  161.     pthread_mutex_unlock(&(pool->pool_mutex));  
  162.      /*好了，等待队列中有任务了，唤醒一个等待线程；*/  
  163.     pthread_cond_signal(&(pool->pool_cond));  
  164.     return 0;  
  165. }  
  166.   
  167. int pool_destory()  
  168. {  
  169.     if (pool->is_destory)  
  170.         return -1;  
  171.     pool->is_destory = 1;  
  172.      /*唤醒所有等待线程，线程池要销毁了*/  
  173.     pthread_cond_broadcast(&(pool->pool_cond));  
  174.   
  175.     int i;  
  176.     for (i = 0; i < pool->thread_max_num; i++)  
  177.         pthread_join(pool->thread_id[i], NULL );  
  178.     /*销毁各种变量*/  
  179.     free(pool->thread_id);  
  180.   
  181.     Thread_worker *temp = NULL;  
  182.     while (pool->worker_queue_head != NULL )  
  183.     {  
  184.         temp = pool->worker_queue_head;  
  185.         pool->worker_queue_head = pool->worker_queue_head->next;  
  186.         free(temp);  
  187.     }  
  188.   
  189.     pthread_mutex_destroy(&(pool->pool_mutex));  
  190.     pthread_cond_destroy(&(pool->pool_cond));  
  191.   
  192.     free(pool);  
  193.     pool = NULL;  
  194.     return 0;  
  195. }  
  196.   
  197. ///////////////////////////////////////   
  198. //下面的代码就是如何调用thread pool   
  199. ///////////////////////////////////////   
  200.   
  201. void * my_process(void *arg)  
  202. {  
  203.     printf("Thread_id is 0x%x , working on task %d\n", pthread_self(),  
  204.             *(int *) arg);  
  205.   
  206.     sleep(1);  
  207.     return NULL ;  
  208. }  
  209.   
  210. int main(int argc, char *argv[])  
  211. {  
  212.     pool_init(3);  
  213.   
  214.     int *working_num = (int *) malloc(sizeof(int) * 5);  
  215.     int i = 0;  
  216.     for (; i < 5; i++)  
  217.     {  
  218.         working_num[i] = i;  
  219.         pool_add_worker(my_process, &working_num[i]);  
  220.     }  
  221.   
  222.     sleep(5);  
  223.     pool_destory();  
  224.     free(working_num);  
  225.     return 0;  
  226. }  
  227. </PRE><BR><BR>
关系数据库特征 关系数据库特征
原创粉丝点击
热门IT博客
专门下破解软件的软件专门下破解软件的软件
越南 中国 知乎越南 中国 知乎
电路模拟仿真软件
免root字体软件
果壳网 知乎
数据表格网页
淘宝装修模板怎么复制
java 成员方法
英雄古达剧情知乎
笔记本电脑wifi软件
南泥湾种鸦片证据知乎
nginx 会话粘滞
网络系统集成质量控制
业务元数据
定时关机软件下载
大数据立法草案
c语言可以干什么
淘宝卖家级别怎么分
网络新媒体加盟
java获取本机ip
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 大江埔古村旅游 蟳埔村旅游 寒门首埔 514200大埔网 大埔论坛网 大埔丰溪森林度假区 埔寨 梅州大埔 大埔动态 下埔 蟳埔村 大埔安娜在线播放 埔组词 下埔边 皇埔爵苏玖 梅州大埔旅游景点 大埔网大埔论坛 下畲埔 柬埔塞 大埔旅游景点大全 大埔招工 大埔安娜 前埔 大埔县委书记林健雄出事 梅州市大埔县 那天凌晨我坐上旺角去大埔 中基协 宋中基 中基 000972中基健康股吧 中基集团 中基健康股票 石家庄中基礼域二手房 中盛醇基燃料 新中基 000972中基健康 中基健康 中基礼域 中基牌番茄红素价格 中基饲料 中铁中基

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里