Linux c 简易线程池

参考别人的代码 自己手写了一个线程池，备忘，自己也是刚接触线程池，和我一样的同学，建议以main->create_thread_pool->add_task_to_list->destroy_thread_pool->thread_func的流程看下去。

/*
     线程池 2014年2月18日 09:46:38
*/
#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__
#include<pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>


//typedef BOOL int

/*
    task_list 任务链表
    task_func: 任务
    arg      :传递给任务的参数  
*/

typedef struct _task_list
    {
         void * arg;
         void * (*task_func)(void*);
         struct _task_list *next;
    }task_list;

/*
       线程池
       1.n_max_thread       线程池中的最大线程数
       2.task_list_head     任务链表
       3.b_stop_thread_pool 线程池开关，判断线程池是否关闭
       4.thread_id          线程id组
       5.cond               触发条件
       6.mutex              task任务队列锁
*/

typedef struct _thread_pool
    {
         int          n_max_thread;
         task_list*   task_list_head;
         int          b_stop_thread_pool;
         pthread_t*   thread_id;
         pthread_cond_t  cond;
         pthread_mutex_t mutex;
    }thread_pool_t;


int create_thread_pool(int _n_max_thread);
int add_task_to_list(void* (*_task_func)(void*), void* _arg );
int destroy_thread_pool();


#endif//__THREAD_POOL_H__

#include "thread_pool.h"

#define malloc_err(p) if((p) == NULL){ perror("p:"); return -1;}

thread_pool_t * g_thread_pool = NULL;//初始化全局线程池

int g_nTatal_thread = 0;

static int total_task(task_list* _head)//计算当前任务链表中剩余任务数
{
     
    int n_total = 0;
    if( _head == NULL ) return n_total;
    while( _head )
    {    
    	   n_total++;
        _head = _head -> next;
    }
    return n_total;

}

/*线程函数*/
static void* thread_func(void* arg)
{
    task_list* head_bak;
    while(1)//线程函数不退出，执行完一个任务之后继续阻塞
    {   
    	  
        pthread_mutex_lock(&g_thread_pool->mutex);
        while( !g_thread_pool->b_stop_thread_pool && !g_thread_pool ->task_list_head )//当线程池未关闭且任务链表中没有任务
            {
                pthread_cond_wait(&g_thread_pool->cond, &g_thread_pool->mutex);                             
            }
            
            if(g_thread_pool -> b_stop_thread_pool)//线程池开关关闭，线程被broastcast唤醒 
            	   {
            	         pthread_mutex_unlock(&g_thread_pool->mutex);//解锁
            	         pthread_exit(0);//线程退出
            	    }
             head_bak = g_thread_pool -> task_list_head;//取出第一个任务
             g_thread_pool -> task_list_head = g_thread_pool -> task_list_head -> next;//任务节点后移
             
           printf("线程摘走一个任务后：剩余任务数:%d, %s \n",total_task(g_thread_pool -> task_list_head),__func__);  
             pthread_mutex_unlock(&g_thread_pool->mutex);//打开任务链表锁
             head_bak -> task_func( head_bak -> arg );//执行取出的任务，并导入参数
             
             free(head_bak);//释放任务节点空间
             head_bak = NULL;
             
             // 传入的任务执行时间过短，加一个sleep可唤醒线程池中的其他线程
             //否则只有一个线程在执行任务链表中的任务
             sleep(1);
    }
}
/*
      create_thread_pool 创建并初始化线程池
      _nMax_thread       初始化线程池中线程的数量
*/
int create_thread_pool(int _n_max_thread)
{
	    g_thread_pool = (thread_pool_t*)malloc(sizeof(thread_pool_t));//开辟线程池空间
	   // malloc( g_thread_pool);
	    g_thread_pool -> n_max_thread       = _n_max_thread;//初始化线程池中线程的数量
	    g_thread_pool -> b_stop_thread_pool = 0;//初始化线程池开关
	    g_thread_pool -> task_list_head     = NULL;//初始化任务列表
	    
	    
	    g_thread_pool -> thread_id = (pthread_t*)malloc(sizeof(pthread_t) * g_thread_pool->n_max_thread);//开辟空间存放线程ID
	    
	    int n_index;
	    for( n_index = 0; n_index < g_thread_pool ->n_max_thread; n_index++ )
	    {
	          pthread_create(&g_thread_pool ->thread_id[n_index], NULL, thread_func, NULL );//可加出错处理
	    }
	    
	    if( pthread_mutex_init(&g_thread_pool -> mutex, NULL) == -1 )
	    	return -1;
	    
	    if( pthread_cond_init(&g_thread_pool -> cond, NULL) == -1 )
	    	return -1;
	       
	    return 0;	
}
int add_task_to_list(void* (*_task_func)(void*), void* _arg )
{
     
     if( _task_func == NULL ) return -1;
     task_list * task_tmp = (task_list*)malloc(sizeof(task_list));//开辟任务节点空间
     //malloc_err(task_list);
     task_tmp -> task_func = _task_func;
     task_tmp -> arg = _arg;
     task_tmp -> next = NULL;//填充节点
     
     pthread_mutex_lock(&g_thread_pool->mutex);//操作任务链表之前先加锁
     
     if( g_thread_pool -> task_list_head == NULL )//判断头节点为空，当前任务链表没有任务
     	 {
     	      g_thread_pool -> task_list_head = task_tmp;
     	 }
     else
       {
         task_list * head_bak = g_thread_pool -> task_list_head;
         while( head_bak ->next != NULL )//找到任务链表中的最后一个节点，插入新任务
             {
                  head_bak = head_bak -> next;
             } 
             head_bak -> next = task_tmp;	
       }
       
       printf("当前任务数:%d, %s \n",total_task(g_thread_pool -> task_list_head),__func__);
       
       //任务链表中有新任务，唤醒阻塞等待的线程
       pthread_cond_signal(&g_thread_pool->cond);
       
       pthread_mutex_unlock(&g_thread_pool->mutex);
       
       return 0;
     
}
int destroy_thread_pool()
{
    if( g_thread_pool -> b_stop_thread_pool /* == 1*/)//如果线程池已关闭
        {
            return 0;
        }
    g_thread_pool -> b_stop_thread_pool = 1;//首先关闭开关
    pthread_mutex_lock(&g_thread_pool->mutex);
    pthread_cond_broadcast(&g_thread_pool->cond);//唤醒所有阻塞的进程
    pthread_mutex_unlock(&g_thread_pool->mutex);
    
    //防止僵尸进程,等待线程池中所有线程结束
    int n_index;
    for( n_index = 0; n_index < g_thread_pool -> n_max_thread; ++n_index )
        {
            pthread_join(g_thread_pool -> thread_id[n_index], NULL);
        }
     
     free(g_thread_pool -> thread_id ); //释放线程ID空间
     g_thread_pool -> thread_id = NULL;

     task_list *head_bak =  g_thread_pool -> task_list_head;
     while( head_bak != NULL )//释放任务链表空间
         {
             g_thread_pool -> task_list_head = g_thread_pool -> task_list_head -> next;
             free(head_bak);
             head_bak =  g_thread_pool -> task_list_head;
         }
     
    
     pthread_mutex_destroy(&g_thread_pool->mutex);
     pthread_cond_destroy(&g_thread_pool->cond);
     free(g_thread_pool);//释放掉线程池空间
     g_thread_pool = NULL;
      
    return 0;
}

测试代码

#include<stdio.h>
#include<stdlib.h>
#include"thread_pool.h"

void* task(void* arg)
{
     printf("当前线程[ID]: %u, [arg]:%d \n",(unsigned int)pthread_self(), arg);
}

int  main()
{
     create_thread_pool(5);
    
    int i;
    for(i=1; i<=20; ++i)
    {
        add_task_to_list(task, (void*)i);
    }
    
    
    sleep(8);
       
    destroy_thread_pool();

    return 0;
}

不太会写makefile，勉强能用

all:test
test:test.o thread_pool.o
	gcc  test.o thread_pool.o -o test -lpthread
test.o:
	gcc -c test.c thread_pool.h
thread_pool.o:
	gcc -c thread_pool.c thread_pool.h 

.PHONY:clean
clean:
	rm -f test *.o
	 rm -f *.gch