Linux網絡編程：線程池的使用

一、什麼是線程池

應用程序可以有多個線程，這些線程在休眠狀態中需要耗費大量時間來等待事件發生。其他線程可能進入睡眠狀態，並且僅定期被喚醒以輪循更改或更新狀態信息，然後再次進入休眠狀態。為了簡化對這些線程的管理，.NET框架為每個進程提供了一個線程池，一個線程池有若干個等待操作狀態，當一個等待操作完成時，線程池中的輔助線程會執行回調函數。線程池中的線程由系統管理，程序員不需要費力於線程管理，可以集中精力處理應用程序任務。

線程池是一種多線程處理形式，處理過程中將任務添加到隊列，然後在創建線程後自動啟動這些任務。線程池線程都是後台線程.每個線程都使用默認的堆棧大小,以默認的優先級運行,並處於多線程單元中.如果某個線程在托管代碼中空閒(如正在等待某個事件),則線程池將插入另一個輔助線程來使所有處理器保持繁忙.如果所有線程池線程都始終保持繁忙,但隊列中包含掛起的工作,則線程池將在一段時間後創建另一個輔助線程但線程的數目永遠不會超過最大值.超過最大值的線程可以排隊,但他們要等到其他線程完成後才啟動

二、什麼情況下不要使用線程池

●如果需要使一個任務具有特定優先級

●如果具有可能會長時間運行（並因此阻塞其他任務）的任務

●如果需要將線程放置到單線程單元中（線程池中的線程均處於多線程單元中）

●如果需要永久標識來標識和控制線程，比如想使用專用線程來終止該線程，將其掛起或按名稱發現它

下面給出一個線程池的例子，以供大家參考：

[cpp]

1. #include <stdio.h>    
2. #include <stdlib.h>    
3. #include <unistd.h>    
4. #include <sys/types.h>    
5. #include <pthread.h>    
6. #include <assert.h>    
7.   
8. /*  
9. *線程池裡所有運行和等待的任務都是一個CThread_worker  
10. *由於所有任務都在鏈表裡，所以是一個鏈表結構  
11. */   
12. typedef struct worker   
13. {   
14.     /*回調函數，任務運行時會調用此函數，注意也可聲明成其它形式*/   
15.     void *(*process) (void *arg);   
16.     void *arg;/*回調函數的參數*/   
17.     struct worker *next;   
18.   
19. } CThread_worker;   
20.   
21.   
22.   
23. /*線程池結構*/   
24. typedef struct   
25. {   
26.     pthread_mutex_t queue_lock;   
27.     pthread_cond_t queue_ready;   
28.   
29.     /*鏈表結構，線程池中所有等待任務*/   
30.     CThread_worker *queue_head;   
31.   
32.     /*是否銷毀線程池*/   
33.     int shutdown;   
34.     pthread_t *threadid;   
35.     /*線程池中允許的活動線程數目*/   
36.     int max_thread_num;   
37.     /*當前等待隊列的任務數目*/   
38.     int cur_queue_size;   
39.   
40. } CThread_pool;   
41.   
42.   
43.   
44. int pool_add_worker (void *(*process) (void *arg), void *arg);   
45. void *thread_routine (void *arg);   
46.   
47.   
48.   
49. static CThread_pool *pool = NULL;   
50. void pool_init (int max_thread_num)   
51. {   
52.     pool = (CThread_pool *) malloc (sizeof (CThread_pool));   
53.   
54.     pthread_mutex_init (&(pool->queue_lock), NULL);   
55.     pthread_cond_init (&(pool->queue_ready), NULL);   
56.   
57.     pool->queue_head = NULL;   
58.   
59.     pool->max_thread_num = max_thread_num;   
60.     pool->cur_queue_size = 0;   
61.   
62.     pool->shutdown = 0;   
63.   
64.     pool->threadid =   
65.         (pthread_t *) malloc (max_thread_num * sizeof (pthread_t));   
66.     int i = 0;   
67.     for (i = 0; i < max_thread_num; i++)   
68.     {    
69.         pthread_create (&(pool->threadid[i]), NULL, thread_routine,   
70.                 NULL);   
71.     }   
72. }   
73.   
74.   
75.   
76. /*向線程池中加入任務*/   
77. int   
78. pool_add_worker (void *(*process) (void *arg), void *arg)   
79. {   
80.     /*構造一個新任務*/   
81.     CThread_worker *newworker =   
82.         (CThread_worker *) malloc (sizeof (CThread_worker));   
83.     newworker->process = process;   
84.     newworker->arg = arg;   
85.     newworker->next = NULL;/*別忘置空*/   
86.   
87.     pthread_mutex_lock (&(pool->queue_lock));   
88.     /*將任務加入到等待隊列中*/   
89.     CThread_worker *member = pool->queue_head;   
90.     if (member != NULL)   
91.     {   
92.         while (member->next != NULL)   
93.             member = member->next;   
94.         member->next = newworker;   
95.     }   
96.     else   
97.     {   
98.         pool->queue_head = newworker;   
99.     }   
100.   
101.     assert (pool->queue_head != NULL);   
102.   
103.     pool->cur_queue_size++;   
104.     pthread_mutex_unlock (&(pool->queue_lock));   
105.     /*好了，等待隊列中有任務了，喚醒一個等待線程；  
106.     注意如果所有線程都在忙碌，這句沒有任何作用*/   
107.     pthread_cond_signal (&(pool->queue_ready));   
108.     return 0;   
109. }   
110.   
111.   
112.   
113. /*銷毀線程池，等待隊列中的任務不會再被執行，但是正在運行的線程會一直  
114. 把任務運行完後再退出*/   
115. int pool_destroy ()   
116. {   
117.     if (pool->shutdown)   
118.         return -1;/*防止兩次調用*/   
119.     pool->shutdown = 1;   
120.   
121.     /*喚醒所有等待線程，線程池要銷毀了*/   
122.     pthread_cond_broadcast (&(pool->queue_ready));   
123.   
124.     /*阻塞等待線程退出，否則就成僵屍了*/   
125.     int i;   
126.     for (i = 0; i < pool->max_thread_num; i++)   
127.         pthread_join (pool->threadid[i], NULL);   
128.     free (pool->threadid);   
129.   
130.     /*銷毀等待隊列*/   
131.     CThread_worker *head = NULL;   
132.     while (pool->queue_head != NULL)   
133.     {   
134.         head = pool->queue_head;   
135.         pool->queue_head = pool->queue_head->next;   
136.         free (head);   
137.     }   
138.     /*條件變量和互斥量也別忘了銷毀*/   
139.     pthread_mutex_destroy(&(pool->queue_lock));   
140.     pthread_cond_destroy(&(pool->queue_ready));   
141.        
142.     free (pool);   
143.     /*銷毀後指針置空是個好習慣*/   
144.     pool=NULL;   
145.     return 0;   
146. }   
147.   
148.   
149.   
150. void * thread_routine (void *arg)   
151. {   
152.     printf ("starting thread 0x%x\n", pthread_self ());   
153.     while (1)   
154.     {   
155.         pthread_mutex_lock (&(pool->queue_lock));   
156.         /*如果等待隊列為0並且不銷毀線程池，則處於阻塞狀態; 注意  
157.         pthread_cond_wait是一個原子操作，等待前會解鎖，喚醒後會加鎖*/   
158.         while (pool->cur_queue_size == 0 && !pool->shutdown)   
159.         {   
160.             printf ("thread 0x%x is waiting\n", pthread_self ());   
161.             pthread_cond_wait (&(pool->queue_ready), &(pool->queue_lock));   
162.         }   
163.   
164.         /*線程池要銷毀了*/   
165.         if (pool->shutdown)   
166.         {   
167.             /*遇到break,continue,return等跳轉語句，千萬不要忘記先解鎖*/   
168.             pthread_mutex_unlock (&(pool->queue_lock));   
169.             printf ("thread 0x%x will exit\n", pthread_self ());   
170.             pthread_exit (NULL);   
171.         }   
172.   
173.         printf ("thread 0x%x is starting to work\n", pthread_self ());   
174.   
175.         /*assert是調試的好幫手*/   
176.         assert (pool->cur_queue_size != 0);   
177.         assert (pool->queue_head != NULL);   
178.            
179.         /*等待隊列長度減去1，並取出鏈表中的頭元素*/   
180.         pool->cur_queue_size--;   
181.         CThread_worker *worker = pool->queue_head;   
182.         pool->queue_head = worker->next;   
183.         pthread_mutex_unlock (&(pool->queue_lock));   
184.   
185.         /*調用回調函數，執行任務*/   
186.         (*(worker->process)) (worker->arg);   
187.         free (worker);   
188.         worker = NULL;   
189.     }   
190.     /*這一句應該是不可達的*/   
191.     pthread_exit (NULL);   
192. }  
193.   
194. void * myprocess (void *arg)   
195. {   
196.     printf ("threadid is 0x%x, working on task %d\n", pthread_self (),*(int *) arg);   
197.     sleep (1);/*休息一秒，延長任務的執行時間*/   
198.     return NULL;   
199. }   
200.   
201. int main (int argc, char **argv)   
202. {   
203.     pool_init (3);/*線程池中最多三個活動線程*/   
204.        
205.     /*連續向池中投入10個任務*/   
206.     int *workingnum = (int *) malloc (sizeof (int) * 10);   
207.     int i;   
208.     for (i = 0; i < 10; i++)   
209.     {   
210.         workingnum[i] = i;   
211.         pool_add_worker (myprocess, &workingnum[i]);   
212.     }   
213.     /*等待所有任務完成*/   
214.     sleep (5);   
215.     /*銷毀線程池*/   
216.     pool_destroy ();   
217.   
218.     free (workingnum);   
219.     return 0;   
220. }