是其实也就是任务分发器,池子里预先跑着N个线程,可以往池子里提交任务。相对线程不断创建和销毁,特别对于大量的短时任务,线程池显然是很节省资源的。直接上代码:
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
typedef void* (*job)(void*);
#define THREAD_PROC(i) (thread##i)
struct pthread_pool_t
{
pthread_mutex_t lock;
pthread_rwlock_t flag_lock;
pthread_t id;
job working_job;
int flag;
void* job_args;
struct pthread_pool_t* next;
};
void init_pool(struct pthread_pool_t* pool)
{
pool->id = 0;
pool->working_job = 0;
pool->flag = 0;
pool->next = NULL;
pool->job_args = 0;
pthread_mutex_init(&pool->lock,NULL);
pthread_rwlock_init(&pool->flag_lock,NULL);
}
void print_pool(struct pthread_pool_t* pool)
{
#if 0
printf("pool->lock = 0x%x\n",pool->lock);
printf("pool->id = 0x%x\n",pool->id);
printf("pool->working_job = 0x%x\n",pool->working_job);
printf("pool->flag = 0x%x\n",pool->flag);
printf("pool->args = 0x%x\n",pool->job_args);
printf("pool->next = 0x%x\n",pool->next);
#endif
}
void* thread1(void* p)
{
struct pthread_pool_t* ptr = (struct pthread_pool_t*)(p);
while(1){
//set a rwlock write-mode here , post_job will block there,
//only when ptr->flag is changed
pthread_rwlock_wrlock(&ptr->flag_lock);
/*printf("thread1 ... lock here\n");*/
pthread_mutex_lock(&(ptr->lock));
printf("thread1 got job = 0x%x\n",(unsigned int)ptr->working_job);
if(ptr->flag == 1){
ptr->flag = 0;
pthread_rwlock_unlock(&ptr->flag_lock);
(*ptr->working_job)(ptr->job_args);
}
//ptr->flag = 0;
//printf("thread1 done\n");
ptr->flag = 1;
//pthread_mutex_lock(&(ptr->lock));
}
return (void*)0;
}
void* thread2(void* p)
{
struct pthread_pool_t* ptr = (struct pthread_pool_t*)(p);
while(1) {
pthread_rwlock_wrlock(&ptr->flag_lock);
/*printf("thread2 ... lock here\n");*/
pthread_mutex_lock(&(ptr->lock));
printf("thread2 got job = 0x%x\n",(unsigned int)ptr->working_job);
if(ptr->flag == 1){
ptr->flag = 0;
pthread_rwlock_unlock(&ptr->flag_lock);
(*ptr->working_job)(ptr->job_args);
}
//ptr->flag = 0;
//printf("thread2 done\n");
ptr->flag = 1;
//pthread_mutex_lock(&(ptr->lock));
}
return (void*)0;
}
void* thread3(void* p)
{
struct pthread_pool_t* ptr = (struct pthread_pool_t*)(p);
while(1) {
pthread_rwlock_wrlock(&ptr->flag_lock);
/*printf("thread3 ... lock here\n");*/
pthread_mutex_lock(&(ptr->lock));
printf("thread3 got job = 0x%x\n",(unsigned int)ptr->working_job);
if(ptr->flag == 1){
ptr->flag = 0;
pthread_rwlock_unlock(&ptr->flag_lock);
(*ptr->working_job)(ptr->job_args);
}
//printf("thread3 done\n");
ptr->flag = 1;
//pthread_mutex_lock(&(ptr->lock));
}
return (void*)0;
}
int init_pthread_pool(struct pthread_pool_t** pool)
{
int i = 0;
job prepared_job[3] = {0};
struct pthread_pool_t* ptr = NULL;
struct pthread_pool_t* old = NULL;
prepared_job[0] = thread1;
prepared_job[1] = thread2;
prepared_job[2] = thread3;
for(;i < 3 ; i++) {
//printf("malloc\n");
ptr = (struct pthread_pool_t* )malloc(sizeof(struct pthread_pool_t));
init_pool(ptr);
/*//print_pool(ptr);*/
if(old != NULL) {
old->next = ptr;
//printf("old->next = ptr\n");
}
if(ptr == NULL) {
printf("init_pthread_pool malloc error\n");
return -1;
}
//Header fixed
if(*pool == NULL) {
//printf("*pool\n");
*pool = ptr;
}
//Init flag
ptr->flag = 1;
//ptr->lock = PTHREAD_MUTEX_INITIALIZER;
//Lock first
pthread_mutex_lock(&(ptr->lock));
pthread_create(&(ptr->id),NULL,prepared_job[i],ptr);
//Next
old = ptr;
//printf("old = ptr\n");
}
/*printf("pool = 0x%x\n",(int)pool);*/
//printf("In init\n");
print_pool(*pool);
//Wait all thread ready
sleep(1);
return 0;
}
void release_pthread_pool(struct pthread_pool_t* header)
{
if(header == NULL)
return;
struct pthread_pool_t* ptr_pool = header;
struct pthread_pool_t* ptr_free = ptr_pool;
while(ptr_pool->next != NULL){
ptr_pool = ptr_pool->next;
pthread_mutex_destroy(&(ptr_free->lock));
pthread_rwlock_destroy(&(ptr_free->flag_lock));
pthread_cancel(ptr_pool->id);
free(ptr_free);
ptr_free = ptr_pool;
}
free(ptr_pool);
}
/**
* @brief post_job
* @param job
* @param args
* @param pool
* @return
*/
int post_job(job job,void* args, struct pthread_pool_t* pool)
{
int ret;
struct pthread_pool_t* ptr = pool;
//printf("head = 0x%x\n",(int)ptr);
//get non-busy thread id
while(ptr != NULL) {
//printf("post_job Start flag = %d\n",ptr->flag);
//Avoid dead lock
ret = pthread_rwlock_tryrdlock(&ptr->flag_lock);
if(ret != 0) {
//printf("Sleep for a while\n");
//usleep(10000);
} else {
printf("Should not lock\n");
pthread_rwlock_unlock(&(ptr->flag_lock));
}
//print_pool(ptr);
//try to get flag lock here if not block
if(ptr->flag == 1) {
//printf("post_job Register job=0x%x\n",job);
ptr->working_job = job;
ptr->job_args = args;
//deliver job to thread`
pthread_mutex_unlock(&(ptr->lock));
//ptr->flag = 0;
return 0;
} else {
//printf("post_job Next\n");
ptr = ptr->next;
}
}
printf("Ptr == NULL\n");
//Ptr == NULL or pool busy , still not find a working_job.
return -1;
}
int remove_job(job job,struct pthread_pool_t* pool)
{
return 0;
}
void* a_job(void* args)
{
printf("Job a running\n");
sleep(1);
printf("Job a done\n");
return (void*)0;
}
void* b_job(void* args)
{
printf("Job b running\n");
sleep(1);
printf("Job b done\n");
return (void*)0;
}
void* c_job(void* args)
{
printf("Job c running\n");
printf("Job c done\n");
return (void*)0;
}
int main(int argc, char* argv[])
{
printf("Go\n");
int ret;
struct pthread_pool_t* ThreadPool = NULL;
init_pthread_pool(&ThreadPool);
#if 1
//printf("ThreadPool\n");
//print_pool(ThreadPool);
#endif
/*printf("ThreadPool = 0x%x\n",(struct pthread_pool_t*)(&ThreadPool));*/
#if 0
ret = post_job(a_job,NULL, ThreadPool);
if(ret)
printf("post_job 1 failed\n");
ret = post_job(b_job,NULL, ThreadPool);
if(ret)
printf("post_job 2 failed\n");
ret =post_job(c_job,NULL, ThreadPool);
if(ret)
printf("post_job 3 failed\n");
#endif
int count = 0;
do{
if(count % 2)
ret =post_job(c_job,NULL, ThreadPool);
else
ret =post_job(a_job,NULL, ThreadPool);
if(ret)
printf("post_job may failed\n");
printf("Count = %d\n",count);
usleep(200000);
}while(count++ < 100);
release_pthread_pool(ThreadPool);
getchar();
return 0;
}
运行结果
取count=5
Go
Count = 0
thread1 got job = 0x40101f
Job a running
Should not lock
Count = 1
thread2 got job = 0x401081
Job c running
Job c done
Should not lock
Count = 2
thread2 got job = 0x40101f
Job a running
Should not lock
Should not lock
Count = 3
thread3 got job = 0x401081
Job c running
Job c done
Should not lock
Should not lock
Count = 4
thread3 got job = 0x40101f
Job a running
Job a done
Count = 5
thread1 got job = 0x401081
Job c running
Job c done
Count = 0
thread1 got job = 0x40101f
Job a running
Should not lock
Count = 1
thread2 got job = 0x401081
Job c running
Job c done
Should not lock
Count = 2
thread2 got job = 0x40101f
Job a running
Should not lock
Should not lock
Count = 3
thread3 got job = 0x401081
Job c running
Job c done
Should not lock
Should not lock
Count = 4
thread3 got job = 0x40101f
Job a running
Job a done
Count = 5
thread1 got job = 0x401081
Job c running
Job c done
说明
post_job是异步的。在资源不足时,提交会失败。
提交的任务越密集,池子初始化的线程越少,提交越容易失败。
实现的关键也是post_job.使用了两把锁:
一把锁是post_job唤醒thread,之后调用job的cb;
另一把锁,用来同步flag。使用trylock防止第1死锁。