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

http://www.linuxidc.com/Linux/2013-01/77619.htm

有时我们会需要大量线程来处理一些相互独立的任务，为了避免频繁的申请释放线程所带来的开销，我们可以使用线程池。下面是一个C语言实现的简单的线程池。

头文件：

   1: #ifndef THREAD_POOL_H__

   2: #define THREAD_POOL_H__

3:

   4: #include <pthread.h>

5:

   6: /* 要执行的任务链表 */

   7: typedef struct tpool_work {

   8:     void*               (*routine)(void*);       /* 任务函数 */

   9:     void                *arg;                    /* 传入任务函数的参数 */

  10:     struct tpool_work   *next;

  11: }tpool_work_t;

12:

  13: typedef struct tpool {

  14:     int             shutdown;                    /* 线程池是否销毁 */

  15:     int             max_thr_num;                /* 最大线程数 */

  16:     pthread_t       *thr_id;                    /* 线程ID数组 */

  17:     tpool_work_t    *queue_head;                /* 线程链表 */

  18:     pthread_mutex_t queue_lock;

  19:     pthread_cond_t  queue_ready;

  20: }tpool_t;

21:

  22: /*

  23:  * @brief     创建线程池

  24:  * @param     max_thr_num 最大线程数

  25:  * @return     0: 成功 其他: 失败

  26:  */

  27: int

  28: tpool_create(int max_thr_num);

29:

  30: /*

  31:  * @brief     销毁线程池

  32:  */

  33: void

  34: tpool_destroy();

35:

  36: /*

  37:  * @brief     向线程池中添加任务

  38:  * @param    routine 任务函数指针

  39:  * @param     arg 任务函数参数

  40:  * @return     0: 成功 其他:失败

  41:  */

  42: int

  43: tpool_add_work(void*(*routine)(void*), void *arg);

44:

  45: #endif

实现:

   1: #include <unistd.h>

   2: #include <stdlib.h>

   3: #include <errno.h>

   4: #include <string.h>

   5: #include <stdio.h>

6:

   7: #include "tpool.h"

8:

   9: static tpool_t *tpool = NULL;

10:

  11: /* 工作者线程函数, 从任务链表中取出任务并执行 */

  12: static void*

  13: thread_routine(void *arg)

  14: {

  15:     tpool_work_t *work;

16:

  17:     while(1) {

  18:         /* 如果线程池没有被销毁且没有任务要执行，则等待 */

  19:         pthread_mutex_lock(&tpool->queue_lock);

  20:         while(!tpool->queue_head && !tpool->shutdown) {

  21:             pthread_cond_wait(&tpool->queue_ready, &tpool->queue_lock);

  22:         }

  23:         if (tpool->shutdown) {

  24:             pthread_mutex_unlock(&tpool->queue_lock);

  25:             pthread_exit(NULL);

  26:         }

  27:         work = tpool->queue_head;

  28:         tpool->queue_head = tpool->queue_head->next;

  29:         pthread_mutex_unlock(&tpool->queue_lock);

30:

  31:         work->routine(work->arg);

  32:         free(work);

  33:     }

34:

  35:     return NULL;

  36: }

37:

  38: /*

  39:  * 创建线程池

  40:  */

  41: int

  42: tpool_create(int max_thr_num)

  43: {

  44:     int i;

45:

  46:     tpool = calloc(1, sizeof(tpool_t));

  47:     if (!tpool) {

  48:         printf("%s: calloc failed\n", __FUNCTION__);

  49:         exit(1);

  50:     }

51:

  52:     /* 初始化 */

  53:     tpool->max_thr_num = max_thr_num;

  54:     tpool->shutdown = 0;

  55:     tpool->queue_head = NULL;

  56:     if (pthread_mutex_init(&tpool->queue_lock, NULL) !=0) {

  57:         printf("%s: pthread_mutex_init failed, errno:%d, error:%s\n",

  58:             __FUNCTION__, errno, strerror(errno));

  59:         exit(1);

  60:     }

  61:     if (pthread_cond_init(&tpool->queue_ready, NULL) !=0 ) {

  62:         printf("%s: pthread_cond_init failed, errno:%d, error:%s\n",

  63:             __FUNCTION__, errno, strerror(errno));

  64:         exit(1);

  65:     }

66:

  67:     /* 创建工作者线程 */

  68:     tpool->thr_id = calloc(max_thr_num, sizeof(pthread_t));

  69:     if (!tpool->thr_id) {

  70:         printf("%s: calloc failed\n", __FUNCTION__);

  71:         exit(1);

  72:     }

  73:     for (i = 0; i < max_thr_num; ++i) {

  74:         if (pthread_create(&tpool->thr_id[i], NULL, thread_routine, NULL) != 0){

  75:             printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__,

  76:                 errno, strerror(errno));

  77:             exit(1);

  78:         }

79:

  80:     }

81:

  82:     return 0;

  83: }

84:

  85: /* 销毁线程池 */

  86: void

  87: tpool_destroy()

  88: {

  89:     int i;

  90:     tpool_work_t *member;

91:

  92:     if (tpool->shutdown) {

  93:         return;

  94:     }

  95:     tpool->shutdown = 1;

96:

  97:     /* 通知所有正在等待的线程 */

  98:     pthread_mutex_lock(&tpool->queue_lock);

  99:     pthread_cond_broadcast(&tpool->queue_ready);

 100:     pthread_mutex_unlock(&tpool->queue_lock);

 101:     for (i = 0; i < tpool->max_thr_num; ++i) {

 102:         pthread_join(tpool->thr_id[i], NULL);

 103:     }

 104:     free(tpool->thr_id);

 105:

 106:     while(tpool->queue_head) {

 107:         member = tpool->queue_head;

 108:         tpool->queue_head = tpool->queue_head->next;

 109:         free(member);

 110:     }

 111:

 112:     pthread_mutex_destroy(&tpool->queue_lock);

 113:     pthread_cond_destroy(&tpool->queue_ready);

 114:

 115:     free(tpool);

 116: }

 117:

 118: /* 向线程池添加任务 */

 119: int

 120: tpool_add_work(void*(*routine)(void*), void *arg)

 121: {

 122:     tpool_work_t *work, *member;

 123:

 124:     if (!routine){

 125:         printf("%s:Invalid argument\n", __FUNCTION__);

 126:         return -1;

 127:     }

 128:

 129:     work = malloc(sizeof(tpool_work_t));

 130:     if (!work) {

 131:         printf("%s:malloc failed\n", __FUNCTION__);

 132:         return -1;

 133:     }

 134:     work->routine = routine;

 135:     work->arg = arg;

 136:     work->next = NULL;

 137:

 138:     pthread_mutex_lock(&tpool->queue_lock);

 139:     member = tpool->queue_head;

 140:     if (!member) {

 141:         tpool->queue_head = work;

 142:     } else {

 143:         while(member->next) {

 144:             member = member->next;

 145:         }

 146:         member->next = work;

 147:     }

 148:     /* 通知工作者线程，有新任务添加 */

 149:     pthread_cond_signal(&tpool->queue_ready);

 150:     pthread_mutex_unlock(&tpool->queue_lock);

 151:

 152:     return 0;

 153: }

 154:

 155:

测试代码:

   1: #include <unistd.h>

   2: #include <stdio.h>

   3: #include <stdlib.h>

   4: #include "tpool.h"

5:

   6: void *func(void *arg)

   7: {

   8:     printf("thread %d\n", (int)arg);

   9:     return NULL;

  10: }

11:

  12: int

  13: main(int arg, char **argv)

  14: {

  15:     if (tpool_create(5) != 0) {

  16:         printf("tpool_create failed\n");

  17:         exit(1);

  18:     }

19:

  20:     int i;

  21:     for (i = 0; i < 10; ++i) {

  22:         tpool_add_work(func, (void*)i);

  23:     }

  24:     sleep(2);

  25:     tpool_destroy();

  26:     return 0;

  27: }

这个实现是在调用tpool_destroy之后，仅将当前正在执行的任务完成之后就会退出，我们也可以修改代码使得线程池在执行完任务链表中所有任务后再退出。

C语言实现的简单的线程池相关推荐

C语言实现简单的线程池【转】
转自https://blog.csdn.net/hubi0952/article/details/8045094 线程池的基本原理在传统的服务器结构中,常用一个总的线程监听有没有新的客户端连接服务器 ...
【C/C++开发】C++实现简单的线程池
C++实现简单的线程池线程池编程简介: 在我们的服务端的程序中运用了大量关于池的概念,线程池.连接池.内存池.对象池等等.使用池的概念后可以高效利用服务器端的资源,比如没有大量的线程在系统中进行上下 ...
分享：一个简单的线程池的实现
一个简单的线程池的实现 http://my.oschina.net/hejiula/blog/110519
手写一个简单的线程池MyThreadPool
说明手写的一个简单的线程池,旨在帮助了解线程池的工作原理. 核心内容核心工作线程任务阻塞队列定义一个内部类去实现核心工作线程 /*** 内部类:工作的核心线程*/private final c ...
一个简单的线程池设计方案
一个简单的线程池本质上是生产者-消费者模型,一般是线程池负责消费任务,任务分配线程负责生产任务,任务可以由队列.链表或全局变量等数据结构承担.如果生产和消费速度差不多,可以采用环形队列结构:如果任务有 ...
linux下C语言简单实现线程池
0 前言网上关于线程池的例子还是不少,简单明了的倒是比较少,看了网上的资料,打算借鉴网上的一些例子,自己实现以下. 线程的概念就不多说,首先说一下多线程的好处:多线程技术主要解决处理器单元内多个线程 ...
简单C++线程池包装类源码示例
这里给出一个简单的C++线程池包装类,该类具有的特点是: 1.线程池大小是固定的, 一创建后,就不具有伸缩特性. 一般建议是 CPU核心数的2倍或1倍. 2.简单但是很可靠. 3.资源占用极低. 在开 ...
java基础：简单实现线程池
先上原理图:为了更好的在手机上显示,我重新把图画了一遍上代码之前,要先补充一下线程池构造的核心几个点线程池里的核心线程数与最大线程数线程池里真正工作的线程worker 线程池里用来存取任务的队列 ...
android的线程管理器,[Android开源]：一款安全、轻巧、简单的线程池管理器EasyThread...
EasyThread通过对原生的线程池进行封装,可让你更方便的进行线程任务操作. 特性简单轻巧:方法数不过百,无额外次级依赖. 配置灵活:可方便.灵活的对每次所启动的任务,配置线程名.线程优先级等. ...

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

C语言实现的简单的线程池相关推荐

最新文章

热门文章