实例一
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <assert.h>
typedef struct worker //运行和等待的任务链表结构
{
void *(*process) (void *arg); //任务运行时会调用该函数
void *arg;
struct worker *next;
} CThread_worker;
typedef struct //线程池结构
{
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head; //任务链表结构，用于存储线程池中所有的等待任务
int shutdown; //标志符，用于表示是否销毁线程池，1代表销毁，反之0
pthread_t *threadid;
int max_thread_num; //线程池中允许活动的线程数目
int cur_queue_size; //当前任务链表的数目
} CThread_pool;
int pool_add_worker (void *(*process) (void *arg), void *arg); //向线程池中添加一个任务
void *thread_routine (void *arg); //线程体函数
static CThread_pool *pool = NULL;
void
pool_init (int max_thread_num) //预先创建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 < max_thread_num; 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; i < pool->max_thread_num; i++)
{
pthread_join (pool->threadid[i], NULL); //阻塞等待所有线程退出
}
free (pool->threadid);
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) //线程体函数
{
printf ("starting thread 0x%x\n", pthread_self ());
while (1)
{
pthread_mutex_lock (&(pool->queue_lock));
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) //如果打算销毁线程
{
pthread_mutex_unlock (&(pool->queue_lock));
printf ("thread 0x%x will exit \n", pthread_self ());
pthread_exit (NULL);
}
printf ("thread 0x%x is starting to work\n", pthread_self ());
assert (pool->cur_queue_size != 0);
assert (pool->queue_head != NULL);
pool->cur_queue_size--;
CThread_worker *worker = pool->queue_head; //取出第一个任务
pool->queue_head = worker->next;
pthread_mutex_unlock (&(pool->queue_lock));
(*(worker->process)) (worker->arg); //执行该任务
free (worker);
worker = NULL;
}
pthread_exit (NULL);
}
//以下是测试代码
void *myprocess (void *arg)
{
printf ("thread is 0x%x, working on task %d\n", pthread_self (), *(int *) arg);
sleep (1);
return NULL;
}
int main (int ac, char *av[])
{
pool_init (3); //预先创建3个活动线程
//投入十个任务
int *workingnum = (int *) malloc (sizeof (int ) * 10);
int i;
for (i = 0; i < 10; i++)
{
workingnum[i] = i;
pool_add_worker (myprocess, &workingnum[i]);
}
sleep (5);
pool_destroy ();
free (workingnum);
return 0;
}
实例二
typedef struct _thread_pool_t
{
pthread_mutex_t queue_lock ;//任务锁
pthread_cond_t task_cond ;//条件变量
list_t * tasks ;// 任务队列
pthread_t * pthreads ;//线程池
int isdestoried;
int workersnum ;
char ready ;//指定当前是否存在任务（0,1），pthreads任务队列是否可用
thread_task_handler thread_pool_task_handler;//回调函数，线程执行体=mc_thread_entry
}thread_pool_t;
void *thread_entry( void *args )
{
int fd = *(int *)args ;
do_handler_fd( fd );
}
void mc_thread_pool_ini( mc_thread_pool_t * par_tp , int workersnum ,thread_task_handler par_handler ) //创建线程池
{
int err ;
//par_tp = ( thread_pool_t *)malloc( sizeof(thread_pool_t) );
if( par_tp == NULL )
{
fprintf( stderr , "thread_pool_t malloc\n");
return ;
}
par_tp->workersnum = workersnum ;
pthread_mutex_init( &par_tp->queue_lock ,NULL );
pthread_cond_init(&par_tp->task_cond , NULL );
/*
par_tp->queue_lock = PTHREAD_MUTEX_INITIALIZER ;
par_tp->task_cond = PTHREAD_COND_INITIALIZER ;
*/
par_tp->tasks = mc_listcreate() ;
if( par_tp->tasks == NULL )
{
fprintf( stderr , "listcreate() error\n");
//free( par_tp ) ;
return ;
}
par_tp->pthreads = ( pthread_t *)malloc( sizeof( pthread_t )*workersnum );
if( par_tp->pthreads == NULL )
{
fprintf( stderr , "pthreads malloc\n");
//free( par_tp );
mc_freelist( par_tp->tasks ) ;
return NULL ;
}
int i = 0 ;
for( ; i < workersnum ; i++ )
{
fprintf(stderr,"start to create threads\n");
err = pthread_create(&(par_tp->pthreads[i]),NULL,mc_thread_entry,NULL) ;
if( err == -1 )
{
fprintf( stderr , "pthread_create error\n");
//free( par_tp );
mc_freelist( par_tp->tasks ) ;
free(par_tp->pthreads) ;
}
}
par_tp->thread_pool_task_handler = par_handler ;
par_tp->ready = 0 ;
fprintf(stderr,"successed to create threads\n");
}
static void *mc_thread_entry( void *args ) //工作线程
{
void * task ;
for(;;)
{
pthread_mutex_lock( &mc_global_threads_pool.queue_lock ) ;
fprintf(stderr, " locked to wait task\n");
while( mc_global_threads_pool.ready == 0 )
{
pthread_cond_wait( &mc_global_threads_pool.task_cond , &mc_global_threads_pool.queue_lock ) ;
}
task = mc_thread_pool_get_task() ;
fprintf(stderr, "get a task and ready to unlock \n");
pthread_mutex_unlock( &mc_global_threads_pool.queue_lock ) ;
mc_global_threads_pool.thread_pool_task_handler( task ) ;
}
}
void mc_thread_pool_add_task(void *task , size_t tasksize ) //写任务队列 {
pthread_mutex_lock( &mc_global_threads_pool.queue_lock );
fprintf( stderr ,"thread locked and append to list\n");
mc_list_append( mc_global_threads_pool.tasks , task , tasksize ) ;
pthread_mutex_unlock( &mc_global_threads_pool.queue_lock );
fprintf( stderr ,"thread unlocked and successed append to list\n");
mc_global_threads_pool.ready = 1 ;
if( mc_global_threads_pool.ready == 1 )
{
fprintf( stderr ,"signal to threads\n");
pthread_cond_signal( &mc_global_threads_pool.task_cond ) ;
}
}
void *mc_thread_pool_get_task()
{
void * ret_task ;
ret_task = mc_getnode_del( mc_global_threads_pool.tasks , 0 );
if( ret_task == NULL )
{
fprintf(stderr,"get node_del error\n");
}
fprintf( stderr ," got a task\n");
mc_global_threads_pool.ready = 0 ;
if( ret_task == NULL )
{
fprintf(stderr, "getnode_del error\n");
return NULL ;
}
else
return ret_task ;
}
int main()
{
mc_thread_task_t ltask;
ltask.task_num = 1 ;
fprintf(stderr,"begin to ini pool\n");
mc_thread_pool_ini( &mc_global_threads_pool , 20 , my_thread_task_handler );
mc_thread_pool_add_task( <ask , sizeof(mc_thread_task_t) );
int i = 0 ;
for(;i < 10000; i++)
{
ltask.task_num = i ;
mc_thread_pool_add_task( <ask , sizeof(mc_thread_task_t) );
sleep(1);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
