1 /**
2 * threadpool.c
3 *
4 * This file will contain your implementation of a threadpool.
5 * 此文件包含線路池的具體實現(xiàn)
6 */ 7 8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <unistd.h>
11 #include <pthread.h>
12 #include <
string.h>
13 14 #include "threadpool.h"
15 16 typedef
struct _thread_st {
17 pthread_t id;
18 pthread_mutex_t mutex;
19 pthread_cond_t cond;
20 dispatch_fn fn;
21 void *arg;
22 threadpool parent;
23 } _thread;
24 25 // _threadpool is the internal threadpool structure that is
26 // cast to type "threadpool" before it given out to callers
27 // _threadpool是內部線程池結構，轉換成類型“threadpool”在提交給使用者之前
28 typedef
struct _threadpool_st {
29 // you should fill in this structure with whatever you need
30 pthread_mutex_t tp_mutex;
31 pthread_cond_t tp_idle;
32 pthread_cond_t tp_full;
33 pthread_cond_t tp_empty;
34 _thread ** tp_list;
35 int tp_index;
36 int tp_max_index;
37 int tp_stop;
38 39 int tp_total;
40 } _threadpool;
41 42 threadpool create_threadpool(
int num_threads_in_pool)
43 {
44 _threadpool *pool;
45 46 // sanity check the argument
47 //參數(shù)檢查
48 if ((num_threads_in_pool <= 0) || (num_threads_in_pool > MAXT_IN_POOL))
49 return NULL;
50 51 pool = (_threadpool *) malloc(
sizeof(_threadpool));
52 if (pool == NULL) {
53 fprintf(stderr, "Out of memory creating a new threadpool! ");
54 return NULL;
55 }
56 57 // add your code here to initialize the newly created threadpool
58 pthread_mutex_init( &pool->tp_mutex, NULL );
59 pthread_cond_init( &pool->tp_idle, NULL );
60 pthread_cond_init( &pool->tp_full, NULL );
61 pthread_cond_init( &pool->tp_empty, NULL );
62 pool->tp_max_index = num_threads_in_pool;
63 pool->tp_index = 0;
64 pool->tp_stop = 0;
65 pool->tp_total = 0;
66 pool->tp_list = ( _thread ** )malloc(
sizeof(
void * ) * MAXT_IN_POOL );
67 memset( pool->tp_list, 0,
sizeof(
void * ) * MAXT_IN_POOL );
68 69 return (threadpool) pool;
70 }
71 72 int save_thread( _threadpool * pool, _thread * thread )
73 {
74 int ret = -1;
75 76 pthread_mutex_lock( &pool->tp_mutex );
77 78 if( pool->tp_index < pool->tp_max_index ) {
79 pool->tp_list[ pool->tp_index ] = thread;
80 pool->tp_index++;
81 ret = 0;
82 83 pthread_cond_signal( &pool->tp_idle );
84 85 if( pool->tp_index >= pool->tp_total ) {
86 pthread_cond_signal( &pool->tp_full );
87 }
88 }
89 90 pthread_mutex_unlock( &pool->tp_mutex );
91 92 return ret;
93 }
94 95 void * wrapper_fn(
void * arg )
96 {
97 _thread * thread = (_thread*)arg;
98 _threadpool * pool = (_threadpool*)thread->parent;
99 100 for( ; 0 == ((_threadpool*)thread->parent)->tp_stop; ) {
101 thread->fn( thread->arg );
102 103 pthread_mutex_lock( &thread->mutex );
104 if( 0 == save_thread( thread->parent, thread ) ) {
105 pthread_cond_wait( &thread->cond, &thread->mutex );
106 pthread_mutex_unlock( &thread->mutex );
107 }
else {
108 pthread_mutex_unlock( &thread->mutex );
109 pthread_cond_destroy( &thread->cond );
110 pthread_mutex_destroy( &thread->mutex );
111 112 free( thread );
113 break;
114 }
115 }
116 117 pthread_mutex_lock( &pool->tp_mutex );
118 pool->tp_total--;
119 if( pool->tp_total <= 0 ) pthread_cond_signal( &pool->tp_empty );
120 pthread_mutex_unlock( &pool->tp_mutex );
121 122 return NULL;
123 }
124 125 int dispatch_threadpool(threadpool from_me, dispatch_fn dispatch_to_here,
void *arg)
126 {
127 int ret = 0;
128 129 _threadpool *pool = (_threadpool *) from_me;
130 pthread_attr_t attr;
131 _thread * thread = NULL;
132 133 // add your code here to dispatch a thread
134 pthread_mutex_lock( &pool->tp_mutex );
135 136 if( pool->tp_index <= 0 && pool->tp_total >= pool->tp_max_index ) {
137 pthread_cond_wait( &pool->tp_idle, &pool->tp_mutex );
138 }
139 140 if( pool->tp_index <= 0 ) {
141 _thread * thread = ( _thread * )malloc(
sizeof( _thread ) );
142 thread->id = 0;
143 pthread_mutex_init( &thread->mutex, NULL );
144 pthread_cond_init( &thread->cond, NULL );
145 thread->fn = dispatch_to_here;
146 thread->arg = arg;
147 thread->parent = pool;
148 149 pthread_attr_init( &attr );
150 pthread_attr_setdetachstate( &attr,PTHREAD_CREATE_DETACHED );
151 152 if( 0 == pthread_create( &thread->id, &attr, wrapper_fn, thread ) ) {
153 pool->tp_total++;
154 printf( "create thread#%ld ", thread->id );
155 }
else {
156 ret = -1;
157 printf( "cannot create thread " );
158 pthread_mutex_destroy( &thread->mutex );
159 pthread_cond_destroy( &thread->cond );
160 free( thread );
161 }
162 }
else {
163 pool->tp_index--;
164 thread = pool->tp_list[ pool->tp_index ];
165 pool->tp_list[ pool->tp_index ] = NULL;
166 167 thread->fn = dispatch_to_here;
168 thread->arg = arg;
169 thread->parent = pool;
170 171 pthread_mutex_lock( &thread->mutex );
172 pthread_cond_signal( &thread->cond ) ;
173 pthread_mutex_unlock ( &thread->mutex );
174 }
175 176 pthread_mutex_unlock( &pool->tp_mutex );
177 178 return ret;
179 }
180 181 void destroy_threadpool(threadpool destroyme)
182 {
183 _threadpool *pool = (_threadpool *) destroyme;
184 185 // add your code here to kill a threadpool
186 int i = 0;
187 188 pthread_mutex_lock( &pool->tp_mutex );
189 190 if( pool->tp_index < pool->tp_total ) {
191 printf( "waiting for %d thread(s) to finish ", pool->tp_total - pool->tp_index );
192 pthread_cond_wait( &pool->tp_full, &pool->tp_mutex );
193 }
194 195 pool->tp_stop = 1;
196 197 for( i = 0; i < pool->tp_index; i++ ) {
198 _thread * thread = pool->tp_list[ i ];
199 200 pthread_mutex_lock( &thread->mutex );
201 pthread_cond_signal( &thread->cond ) ;
202 pthread_mutex_unlock ( &thread->mutex );
203 }
204 205 if( pool->tp_total > 0 ) {
206 printf( "waiting for %d thread(s) to exit ", pool->tp_total );
207 pthread_cond_wait( &pool->tp_empty, &pool->tp_mutex );
208 }
209 210 for( i = 0; i < pool->tp_index; i++ ) {
211 free( pool->tp_list[ i ] );
212 pool->tp_list[ i ] = NULL;
213 }
214 215 pthread_mutex_unlock( &pool->tp_mutex );
216 217 pool->tp_index = 0;
218 219 pthread_mutex_destroy( &pool->tp_mutex );
220 pthread_cond_destroy( &pool->tp_idle );
221 pthread_cond_destroy( &pool->tp_full );
222 pthread_cond_destroy( &pool->tp_empty );
223 224 free( pool->tp_list );
225 free( pool );
226 }
227 1 class RtThread