最简单的线程池

=================== thread_pool.h ===============================

#ifndef THREAD_POOL_H__
#define THREAD_POOL_H__
  
#include <pthread.h>
  
/* 要执行的任务链表 */
typedef struct tpool_work {
  void*               (*routine)(void*);       /* 任务函数 */
  void                *arg;                    /* 传入任务函数的参数 */
  struct tpool_work   *next;                    
}tpool_work_t;
  
typedef struct tpool {
  int             shutdown;                    /* 线程池是否销毁 */
  int             max_thr_num;                /* 最大线程数 */
  pthread_t       *thr_id;                    /* 线程ID数组 */
  tpool_work_t    *queue_head;                /* 线程链表 */
  pthread_mutex_t queue_lock;                    
  pthread_cond_t  queue_ready;    
}tpool_t;
  
/*
* @brief     创建线程池 
* @param     max_thr_num 最大线程数
* @return     0: 成功 其他: 失败  
*/
int
tpool_create(int max_thr_num);
  
/*
* @brief     销毁线程池 
*/
void
tpool_destroy();
  
/*
@brief     向线程池中添加任务
@param    routine 任务函数指针
@param     arg 任务函数参数
@return     0: 成功 其他:失败 
*/
int
tpool_add_work(void*(*routine)(void*), void *arg);
 
#endif

----------------------------------------------------------------------thread_pool.h-----------------------------------------

========================thread_pool.c ==================================

#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
 
#include "thread_pool.h"
 
static tpool_t *tpool = NULL;
  
 /* 工作者线程函数, 从任务链表中取出任务并执行 */
 static void* 
 thread_routine(void *arg)
 {
     tpool_work_t *work;
    
     while(1) {
         /* 如果线程池没有被销毁且没有任务要执行，则等待 */
         pthread_mutex_lock(&tpool->queue_lock);
         while(!tpool->queue_head && !tpool->shutdown) {///线程池没有被销毁，且没有任务要执行
             pthread_cond_wait(&tpool->queue_ready, &tpool->queue_lock);
         }
         if (tpool->shutdown) {///线程池被销毁
             pthread_mutex_unlock(&tpool->queue_lock);
             pthread_exit(NULL);
         }
         work = tpool->queue_head;
         tpool->queue_head = tpool->queue_head->next;///获得任务后线程池偏移。
         pthread_mutex_unlock(&tpool->queue_lock);
  
         work->routine(work->arg);
         free(work);
      }
      
     return NULL;   
 }
  
 /*
  * 创建线程池 
  */
 int
 tpool_create(int max_thr_num)
  {
      int i;
   
      tpool = calloc(1, sizeof(tpool_t));
      if (!tpool) {
          printf("%s: calloc failed\n", __FUNCTION__);
          exit(1);
      }
     
     /* 初始化 */
     tpool->max_thr_num = max_thr_num;
     tpool->shutdown = 0;///0代表未被销毁
     tpool->queue_head = NULL;
     if (pthread_mutex_init(&tpool->queue_lock, NULL) !=0) {///初始化互斥量
         printf("%s: pthread_mutex_init failed, errno:%d, error:%s\n",
             __FUNCTION__, errno, strerror(errno));
         exit(1);
     }
     if (pthread_cond_init(&tpool->queue_ready, NULL) !=0 ) {///初始化条件变量
         printf("%s: pthread_cond_init failed, errno:%d, error:%s\n", 
             __FUNCTION__, errno, strerror(errno));
         exit(1);
     }
     
     /* 创建工作者线程 */
     tpool->thr_id = calloc(max_thr_num, sizeof(pthread_t));
     if (!tpool->thr_id) {
         printf("%s: calloc failed\n", __FUNCTION__);
         exit(1);
     }
     ///创建线程池
     for (i = 0; i < max_thr_num; ++i) {
         if (pthread_create(&tpool->thr_id[i], NULL, thread_routine, NULL) != 0){
             printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__, 
                 errno, strerror(errno));
             exit(1);
         }
         /*
         优先级 []大于->大于&
         第一个参数为指向线程标识符的指针。
         第二个参数用来设置线程属性。
         第三个参数是线程运行函数的起始地址。
         最后一个参数是运行函数的参数。
         */
         
         
     }    
  
     return 0;
 }
  
 /* 销毁线程池 */
 void
 tpool_destroy()
 {
     int i;
     tpool_work_t *member;
  
     if (tpool->shutdown) {///线程池已经被销毁则直接返回。
         return;
     }
     tpool->shutdown = 1;///代表线程池被设置为销毁。
  
     /* 通知所有正在等待的线程 */
     pthread_mutex_lock(&tpool->queue_lock);
     pthread_cond_broadcast(&tpool->queue_ready);///
     pthread_mutex_unlock(&tpool->queue_lock);
     for (i = 0; i < tpool->max_thr_num; ++i) {
         pthread_join(tpool->thr_id[i], NULL);///回收退出的线程
     }
     free(tpool->thr_id);
  
     while(tpool->queue_head) {
         member = tpool->queue_head;
         tpool->queue_head = tpool->queue_head->next;
         free(member);
     }
  
     pthread_mutex_destroy(&tpool->queue_lock);    
     pthread_cond_destroy(&tpool->queue_ready);
  
     free(tpool);    
 }
  
 /* 向线程池添加任务 */
 int
 tpool_add_work(void*(*routine)(void*), void *arg)
 {
     tpool_work_t *work, *member;
     
     if (!routine){
         printf("%s:Invalid argument\n", __FUNCTION__);
         return -1;
     }
     
     work = malloc(sizeof(tpool_work_t));
     if (!work) {
         printf("%s:malloc failed\n", __FUNCTION__);
         return -1;
     }
     work->routine = routine;
     work->arg = arg;
     work->next = NULL;
  
     pthread_mutex_lock(&tpool->queue_lock);    
     member = tpool->queue_head;
     if (!member) {///当前任务队列为空，添加的为第一个任务
         tpool->queue_head = work;
     } else {///将任务添加到队列的末尾
         while(member->next) {
             member = member->next;
         }
         member->next = work;
     }
     /* 通知工作者线程，有新任务添加 */
     pthread_cond_signal(&tpool->queue_ready);///应该是随机通知一个等待线程
     pthread_mutex_unlock(&tpool->queue_lock);
 
return 0;    
}

--------------------------------------------------thread_pool.c-----------------------------------------

 

=====================test.c=====================

/*
 创建线程池后，线程池while(1)等待任务，tpool_add_work添加任务。
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include "thread_pool.h"
  
 void *func(void *arg)
 {
     printf("thread %d\n", *((int *)arg));
     return NULL;
 }
  
 int
 main(int arg, char **argv)
 {
     if (tpool_create(5) != 0) {
         printf("tpool_create failed\n");
         exit(1);
     }
     
     int i;
     int i_num[10]={0};///使用数组不使用变量的原因是，传入线程后，值可能会变化。
     /*
     例如如果使用变量 i_num = 0；
     for (i = 0; i < 10; ++i) {///添加10个任务到线程池
         tpool_add_work(func, (void*)(&i_num));
     }
     则可能传入的i_num的值不是期望的。
      */
     for(i=0;i<10;++i)
     {
        i_num[i]=i;
     }
     for (i = 0; i < 10; ++i) {///添加10个任务到线程池
         tpool_add_work(func, (void*)(&(i_num[i])));
     }
     sleep(2);
     tpool_destroy();
     return 0;
 }

----------------test.c---------------------

运行结果如下图所示：