非常好用的C语言线程池，自己测试通过

自己写的非常好用的C语言线程，纯C代码，可以随便用。

#include 
#include 
#include 
#include 
#include 
#include 
#include 


#include “threadPool.h“


#ifdef __cplusplus
#if __cplusplus
extern “C“ {
#endif
#endif /* End of #ifdef __cplusplus */

		
static CThread_pool *pool = NULL;
void pool_init （int max_thread_num）
{
	pool = （CThread_pool *）malloc（sizeof（CThread_pool））;

	pthread_mutex_init（&（pool->queue_lock） NULL）;
	pthread_cond_init（&（pool->queue_ready） NULL）;

	pool->queue_head = NULL;
	pool->max_thread_num = max_thread_num;
	pool->cur_queue_size = 0;
	pool->shutdown = 0;
	pool->threadid = （pthread_t *）malloc（max_thread_num * sizeof（pthread_t））;

	int i = 0;
	for （i=0; i	{ 
		pthread_create（&（pool->threadid[i]） NULL thread_routine NULL）;
	}
}
	
	
/*向线程池中加入任务*/
int pool_add_worker （void *（*process）（void *arg） void *arg）
{
    /*构造一个新任务*/
    CThread_worker *newworker = （CThread_worker*）malloc（sizeof（CThread_worker））;
    newworker->process = process;
    newworker->arg  = arg;
    newworker->next = NULL;  /*别忘置空*/
	
    pthread_mutex_lock （&（pool->queue_lock））; 
    /*将任务加入到等待队列中*/
    CThread_worker *member = pool->queue_head;
    if （member != NULL）
	{
        while （member->next != NULL） member = member->next;
        member->next = newworker;
	}
    else
	{
		pool->queue_head = newworker;
	}
	assert（pool->queue_head != NULL）;
	pool->cur_queue_size++;
	pthread_mutex_unlock（&（pool->queue_lock））;

	/*好了，等待队列中有任务了，唤醒一个等待线程*/	
    pthread_cond_signal（&（pool->queue_ready））;
    return 0;
}
	
	
/*销毁线程池，等待队列中的任务不会再被执行，但是正在运行的线程会一直
  把任务运行完后再退出*/
int pool_destroy （）
{
	if （pool->shutdown）
		return -1;/*防止两次调用*/

	pool->shutdown = 1;

	/*唤醒所有等待线程，线程池要销毁了*/
	pthread_cond_broadcast（&（pool->queue_ready））;

    /*阻塞等待线程退出，否则就成僵尸了*/
    int i;
	for （i=0; imax_thread_num; i++）
		pthread_join（pool->threadid[i] NULL）;
	free（pool->threadid） pool->threadid = NULL;
	
    /*销毁等待队列*/
	CThread_worker *head = NULL;
	while （pool->queue_head != NULL）
	{
		head = pool->queue_head;
		pool->queue_head = pool->queue_head->next;
		free（head）;
	}

	/*条件变量和互斥量也别忘了销毁*/
	pthread_mutex_destroy（&（pool->queue_lock））;
	pthread_cond_destroy（&（pool->queue_ready））;
	free（pool） pool=NULL;
	return 0;
}
	
	
void* thread_routine （void *arg）
{	
	for （;;）
    {    
        pthread_mutex_lock （&（pool->queue_lock））;
        /*如果等待队列为0并且不销毁线程池，则处于阻塞状态; 注意
        pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁*/
        while （pool->cur_queue_size == 0 && !pool->shutdown）
        {
             //printf（“thread 0x%x is waiting\n“ pthread_self （））;
             pthread_cond_wait（&（pool->queue_ready） &（pool->queue_lock））;
        }	
	    /*线程池要销毁了*/
	    if （pool->shutdown）
        {
            /*遇到breakcontinuereturn等跳转语句，千万不要忘记先解锁*/
             pthread_mutex_unlock（&（pool->queue_lock））;
             printf（“thr

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     目录           0  2015-12-03 17:27  c语言线程池\
     文件        3987  2015-12-03 17:27  c语言线程池\threadPool.c
     文件        1124  2015-10-22 17:04  c语言线程池\threadPool.h