#ifndef __THRMGR_H__
#define __THRMGR_H__
#include <pthread.h>
#include <sys/time.h>
#include <stdio.h>
#include <time.h>
#include <errno.h>
#include "memory.h"
#include <stdlib.h>
#define FALSE (0)
#define TRUE (1)
typedef struct work_item_tag
{
struct work_item_tag *next;
void *data;
struct timeval time_queued;
}work_item_t;
typedef struct work_queue_tag
{
work_item_t *head;
work_item_t *tail;
int item_count;
}work_queue_t;
typedef enum
{
POOL_INVALID,
POOL_VALID,
POOL_EXIT,
}pool_state_t;
typedef struct threadpool_tag
{
pthread_mutex_t pool_mutex;
pthread_cond_t pool_cond;
pthread_attr_t pool_attr;
pool_state_t state;
int thr_max;
int thr_alive;
int thr_idle;
int idle_timeout;
void (*handler)(void *);
work_queue_t *queue;
}threadpool_t;
threadpool_t *thrmgr_new(int max_threads, int idle_timeout, void (*handler)(void *));
void thrmgr_destroy(threadpool_t *threadpool);
int thrmgr_dispatch(threadpool_t *threadpool, void *user_data);
#endif
work_queue_t *work_queue_new()
{
work_queue_t *work_q = NULL;
work_q = (work_queue_t *) malloc(sizeof(work_queue_t));
work_q->head = work_q->tail = NULL;
work_q->item_count = 0;
return work_q;
}
void work_queue_add(work_queue_t *work_q, void *data)
{
work_item_t *work_item;
if (!work_q)
{
return;
}
work_item = (work_item_t *) malloc(sizeof(work_item_t));
work_item->next = NULL;
work_item->data = data;
gettimeofday(&(work_item->time_queued), NULL);
if (work_q->head == NULL)
{
work_q->head = work_q->tail = work_item;
work_q->item_count = 1;
}
else
{
work_q->tail->next = work_item;
work_q->tail = work_item;
work_q->item_count++;
}
return;
}
void *work_queue_pop(work_queue_t *work_q)
{
work_item_t *work_item;
void *data;
if (!work_q || !work_q->head)
{
return NULL;
}
work_item = work_q->head;
data = work_item->data;
work_q->head = work_item->next;
if (work_q->head == NULL)
{
work_q->tail = NULL;
}
free(work_item);
return data;
}
void thrmgr_destroy(threadpool_t *threadpool)
{
if (!threadpool || (threadpool->state != POOL_VALID))
{
return;
}
if (pthread_mutex_lock(&threadpool->pool_mutex) != 0)
{
printf("!Mutex lock failed\n");
exit(-1);
}
threadpool->state = POOL_EXIT;
/**//* wait for threads to exit */
if (threadpool->thr_alive > 0)
{
/**//*通知兄弟们收工*/
if (pthread_cond_broadcast(&(threadpool->pool_cond)) != 0)
{
pthread_mutex_unlock(&threadpool->pool_mutex);
return;
}
}
while (threadpool->thr_alive > 0)
{
/**//*原来是这位老兄负责等最后一名兄弟的信号啊*/
if (pthread_cond_wait (&threadpool->pool_cond, &threadpool->pool_mutex) != 0)
{
pthread_mutex_unlock(&threadpool->pool_mutex);
return;
}
}
if (pthread_mutex_unlock(&threadpool->pool_mutex) != 0)
{
printf("!Mutex unlock failed\n");
exit(-1);
}
pthread_mutex_destroy(&(threadpool->pool_mutex));
pthread_cond_destroy(&(threadpool->pool_cond));
pthread_attr_destroy(&(threadpool->pool_attr));
free(threadpool->queue);
free(threadpool);
return;
}
threadpool_t *thrmgr_new(int max_threads, int idle_timeout, void (*handler)(void *))
{
threadpool_t *threadpool = NULL;
if (max_threads <= 0)
{
return NULL;
}
threadpool = (threadpool_t *) malloc(sizeof(threadpool_t));
threadpool->queue = work_queue_new();
if (NULL == threadpool->queue)
{
free(threadpool);
return NULL;
}
threadpool->thr_max = max_threads;
threadpool->thr_alive = 0;
threadpool->thr_idle = 0;
threadpool->idle_timeout = idle_timeout;
threadpool->handler = handler;
pthread_mutex_init(&(threadpool->pool_mutex), NULL);
if (pthread_cond_init(&(threadpool->pool_cond), NULL) != 0)
{
free(threadpool->queue);
free(threadpool);
return NULL;
}
if (pthread_attr_init(&(threadpool->pool_attr)) != 0)
{
free(threadpool->queue);
free(threadpool);
return NULL;
}
if (pthread_attr_setdetachstate(&(threadpool->pool_attr), PTHREAD_CREATE_DETACHED) != 0)
{
free(threadpool->queue);
free(threadpool);
return NULL;
}
threadpool->state = POOL_VALID;
return threadpool;
}
/**//*工作线程.该工作线程遍历工作链表,如果有活干就干,没活干就等活干,难怪叫民工*/
void *thrmgr_worker(void *arg)
{
threadpool_t *threadpool = (threadpool_t *) arg;
void *job_data;
int retval, must_exit = FALSE;
struct timespec timeout;
/**//* loop looking for work */
for (;;)
{
if (pthread_mutex_lock(&(threadpool->pool_mutex)) != 0)
{
/**//* Fatal error */
printf("!Fatal: mutex lock failed\n");
exit(-2);
}
timeout.tv_sec = time(NULL) + threadpool->idle_timeout;
timeout.tv_nsec = 0;
threadpool->thr_idle++;
while (((job_data=work_queue_pop(threadpool->queue)) == NULL)&& (threadpool->state != POOL_EXIT))
{
/**//* Sleep, awaiting wakeup ,注意,民工等一段时间,如果没有活干就结束该线程*/
retval = pthread_cond_timedwait(&(threadpool->pool_cond),&(threadpool->pool_mutex), &timeout);
if (retval == ETIMEDOUT)
{
must_exit = TRUE;
break;
}
}
threadpool->thr_idle--;//要干活了,闲着的民工少了一位
if (threadpool->state == POOL_EXIT)
{
must_exit = TRUE;
}
if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0)
{
/**//* Fatal error */
printf("!Fatal: mutex unlock failed\n");
exit(-2);
}
if (job_data)
{
threadpool->handler(job_data);
}
else if (must_exit)
{
/**//*如果没有等到活或者要结束整个线程池时,该线程收工*/
break;
}
}
if (pthread_mutex_lock(&(threadpool->pool_mutex)) != 0)
{
/**//* Fatal error */
printf("!Fatal: mutex lock failed\n");
exit(-2);
}
threadpool->thr_alive--;//活干完了,该走人了(人又少了一个)
if (threadpool->thr_alive == 0)
{
/**//* signal that all threads are finished */
pthread_cond_broadcast(&threadpool->pool_cond);//人都跑光了,谁还听得到这个信号?多次一举吗?
}
if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0)
{
/**//* Fatal error */
printf("!Fatal: mutex unlock failed\n");
exit(-2);
}
return NULL;
}
/**//*创建一个工作线程,如果目前有等待条件信号的工作线程,则唤醒该工作线程处理数据*/
int thrmgr_dispatch(threadpool_t *threadpool, void *user_data)
{
pthread_t thr_id;
if (!threadpool)
{
return FALSE;
}
/**//* Lock the threadpool */
if (pthread_mutex_lock(&(threadpool->pool_mutex)) != 0)
{
printf("!Mutex lock failed\n");
return FALSE;
}
if (threadpool->state != POOL_VALID)
{
if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0)
{
printf("!Mutex unlock failed\n");
return FALSE;
}
return FALSE;
}
work_queue_add(threadpool->queue, user_data);
/**//*只有当目前没有线程idle且目前生成的线程数小于最大线程要求时,创建新的线程*/
if ((threadpool->thr_idle == 0)&&(threadpool->thr_alive < threadpool->thr_max))
{
/**//* Start a new thread */
if (pthread_create(&thr_id, &(threadpool->pool_attr),thrmgr_worker, threadpool) != 0)
{
printf("!pthread_create failed\n");
}
else
{
threadpool->thr_alive++;
}
}
/**//*释放条件信号,如果有正在等待该信号的线程,则该线程运行*/
pthread_cond_signal(&(threadpool->pool_cond));
if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0)
{
printf("!Mutex unlock failed\n");
return FALSE;
}
return TRUE;
}
标准的一个在Linux下用的线程池代码，估计很多人都用得这个，改天把java的那个也贴上来。就怕忘了。
