一个简单的线程池

1. //threadpool.h    
2. #ifndef     __THREADPOOL_H__    
3. #define     __THREADPOOL_H__    
4. #include    <pthread.h>    
5. typedef void* (*task_fun)(void*);    
6. //用链表来维护等待任务    
7. typedef struct threadtask    
8. {    
9.     //任务的执行函数    
10.     task_fun task;    
11.     //执行函数的参数    
12.     void* arg;    
13.     //下一节点    
14.     struct threadtask* next;    
15. }THREAD_TASK;    
16.     
17. void* thr_fun(void* arg);//每个线程执行的函数    
18. int init_task(void);//初始化等待任务链表    
19. int init_pool(void);//初始化线程池    
20. //向任务链表中添加任务    
21. int add_task(task_fun task, void* arg);    
22. int destroy_poll(void);    
23. #endif    

[cpp]  view plain copy print ?

1. //threadpool.c    
2. //对于基本不出现的错误不进行检测    
3. #include    <stdio.h>    
4. #include    <stdlib.h>    
5. #include    <unistd.h>    
6. #include    <string.h>    
7. #include    "threadpool.h"    
8. //线程池中最多允许的线程数    
9. #define     THREADPOOLSIZE 3    
10. //当前等待任务的个数    
11. static unsigned int taskwaittingnum=0;    
12. //taskwaittingnum的锁    
13. pthread_mutex_t g_nummutex= PTHREAD_MUTEX_INITIALIZER;    
14. //等待任务队列的锁    
15. pthread_mutex_t g_taskmutex=PTHREAD_MUTEX_INITIALIZER;    
16. THREAD_TASK* g_pTask=NULL;    
17. pthread_t tid[THREADPOOLSIZE];    
18. //是否销毁线程池    
19. static int isShut=0;    
20. void* thr_fun(void* arg)    
21. {    
22.     task_fun task;    
23.     void* funarg=NULL;    
24.     THREAD_TASK* ptmp=NULL;    
25.         
26.     while(1)    
27.     {    
28.         //如果要销毁线程池，跳出while循环    
29.         if( 1==isShut )     
30.         {    
31.             break;//跳出while循环    
32.         }    
33.         pthread_mutex_lock(&g_nummutex);    
34.         //如果当前没有任务需要调度，休眠5000微妙    
35.         if( 0==taskwaittingnum )    
36.         {    
37.             pthread_mutex_unlock(&g_nummutex);    
38.             usleep(5000);    
39.             continue;    
40.         }    
41.         //当前有任务调度    
42.         else    
43.         {    
44.             //需要写入链表，所以要锁定链表    
45.             pthread_mutex_lock(&g_taskmutex);    
46.             task=g_pTask->next->task;    
47.             funarg=g_pTask->next->arg;    
48.             ptmp=g_pTask->next;    
49.             g_pTask->next=ptmp->next;    
50.             taskwaittingnum--;    
51.             pthread_mutex_unlock(&g_taskmutex);    
52.             pthread_mutex_unlock(&g_nummutex);    
53.                 
54.             free(ptmp);    
55.             ptmp=NULL;    
56.             (*task)(funarg);    
57.         }    
58.     }    
59.     pthread_exit(NULL);    
60. }    
61. //初始化任务链表，首个节点不用来存储任务    
62. int init_task(void)    
63. {    
64.     g_pTask=(THREAD_TASK*)malloc(sizeof(THREAD_TASK));    
65.     if( NULL==g_pTask )    
66.     {    
67.         printf("init_task malloc fails./n");    
68.         return -1;    
69.     }    
70.     memset(g_pTask, 0, sizeof(THREAD_TASK));    
71.     g_pTask->next=NULL;    
72.     return 0;    
73. }    
74. //初始化线程池    
75. int init_pool(void)    
76. {    
77.     int ret;    
78.     int i;    
79.     for( i=0 ; i<THREADPOOLSIZE ; i++ )    
80.     {    
81.         ret=pthread_create(tid+i, NULL, thr_fun, NULL);    
82.         if( ret!=0 )    
83.         {    
84.             printf("init_pool pthread_create:/n%s/n", strerror(ret));    
85.             return -1;    
86.         }    
87.     }    
88.     return 0;       
89. }    
90. int add_task(task_fun task, void* arg)    
91. {    
92.     THREAD_TASK* ptmp=NULL;    
93.     pthread_mutex_lock(&g_nummutex);    
94.     pthread_mutex_lock(&g_taskmutex);    
95.     ptmp=g_pTask;    
96.     while( ptmp->next!=NULL )    
97.     {    
98.         ptmp=ptmp->next;    
99.     }    
100.     ptmp->next=(THREAD_TASK*)malloc(sizeof(THREAD_TASK));    
101.     if( NULL==ptmp->next )    
102.     {    
103.         printf("add_task malloc fails/n");    
104.         return -1;    
105.     }    
106.     ptmp=ptmp->next;    
107.     ptmp->task=task;    
108.     ptmp->arg=arg;    
109.     ptmp->next=NULL;    
110.     taskwaittingnum++;    
111.     pthread_mutex_unlock(&g_nummutex);    
112.     pthread_mutex_unlock(&g_taskmutex);    
113.     return 0;    
114. }    
115. int destroy_pool(void)    
116. {    
117.     isShut=1;    
118.     pthread_mutex_destroy(&g_nummutex);    
119.     pthread_mutex_destroy(&g_taskmutex);    
120.     return 0;    
121. }    

[cpp]  view plain copy print ?

1. //用来测试的main.c    
2. #include    <stdio.h>    
3. #include    "threadpool.h"    
4. void* task1(void* arg)    
5. {    
6.     printf("task1正在运行！/n");    
7.     sleep(10);    
8.     printf("task1运行结束!/n");    
9.     return NULL;    
10. }    
11. void* task2(void* arg)    
12. {    
13.     printf("task2正在运行！/n");    
14.     sleep(10);    
15.     printf("task2运行结束！/n");    
16.     return NULL;    
17. }    
18. void* task3(void* arg)    
19. {    
20.     printf("task3正在运行！/n");    
21.     printf("task3运行结束！/n");    
22.     return NULL;    
23. }    
24. void* task4(void* arg)    
25. {    
26.     printf("task4正在运行！/n");    
27.     printf("task4运行结束！/n");    
28.     return NULL;    
29. }    
30. int main(int argc, char *argv[])    
31. {    
32.     init_task();    
33.     init_pool();    
34.     add_task(task1, NULL);    
35.     add_task(task2, NULL);    
36.     add_task(task3, NULL);    
37.     add_task(task4, NULL);    
38.     sleep(30);    
39.     destroy_pool();    
40.     return 0;    
41. }