/[LeafOK_CVS]/innwebd/thread_pool.cpp
ViewVC logotype

Diff of /innwebd/thread_pool.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.4 by sysadm, Sat Jul 3 15:10:23 2004 UTC Revision 1.5 by sysadm, Sun Jul 4 06:45:23 2004 UTC
# Line 1  Line 1 
1  /*******************************************************/  /*******************************************************/
2  /*                                                     */  /*                                                     */
3  /*  LeafOK Innd                                        */  /*  LeafOK Innbbsd                                     */
4  /*  Copyright (C) LeafOK.com, 2003-2004                */  /*  Copyright (C) LeafOK.com, 2003-2004                */
5  /*                                                     */  /*                                                     */
6  /*  Programmed by Leaf                                 */  /*  Programmed by Leaf                                 */
7  /*  E-mail:leaf@leafok.com  QQ:6049044                 */  /*  E-mail:leaflet@leafok.com  QQ:6049044              */
8  /*                                                     */  /*                                                     */
9  /*  http://bbs.leafok.com                              */  /*  http://bbs.leafok.com                              */
10  /*  http://bbs.leafok.net                              */  /*  http://bbs.leafok.net                              */
# Line 22  thread_pool::thread_pool(UINT uThreadMax Line 22  thread_pool::thread_pool(UINT uThreadMax
22          this->uLastErrorCode = E_NOERROR;          this->uLastErrorCode = E_NOERROR;
23          this->uThreadCount = 0;          this->uThreadCount = 0;
24          this->uThreadMax = uThreadMax;          this->uThreadMax = uThreadMax;
25          this->hThreadKiller = NULL;          this->ulThreadKillerId = 0;
26    
27          if (this->uThreadMax > TS_MAX_THREAD)          if (this->uThreadMax > TS_MAX_THREAD)
28          {          {
# Line 32  thread_pool::thread_pool(UINT uThreadMax Line 32  thread_pool::thread_pool(UINT uThreadMax
32    
33          for (i=0; i < this->uThreadMax; i++)          for (i=0; i < this->uThreadMax; i++)
34          {          {
35                  this->hThreadList[i] = NULL;                  this->ulThreadIdList[i] = 0;
36                  this->uThreadStatusList[i] = S_UNUSED;                  this->uThreadStatusList[i] = S_UNUSED;
37                  this->time_status_set[i] = clock();                  this->time_status_set[i] = clock();
38          }          }
# Line 45  thread_pool::thread_pool(UINT uThreadMax Line 45  thread_pool::thread_pool(UINT uThreadMax
45  thread_pool::~thread_pool(void)  thread_pool::~thread_pool(void)
46  {  {
47          this->DisableKillDeadThread();          this->DisableKillDeadThread();
48            this->KillAllThread();
49  }  }
50    
51  int thread_pool::AddThread(HANDLE hThread, clock_t thread_timeout)  int thread_pool::AddThread(ULONG ulThreadId, clock_t thread_timeout)
52  {  {
53          UINT i;          UINT i;
54    
         if (this->SetLock(true) != 0)  
         {  
                 return this->uLastErrorCode;  
         }  
   
55          if (this->uThreadCount >= this->uThreadMax)          if (this->uThreadCount >= this->uThreadMax)
56          {          {
                 this->SetLock(false);  
57                  this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;                  this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
58                  return E_MAX_THREAD_EXCEEDED;                  return E_MAX_THREAD_EXCEEDED;
59          }          }
# Line 69  int thread_pool::AddThread(HANDLE hThrea Line 64  int thread_pool::AddThread(HANDLE hThrea
64                  return E_INVALID_TIMEOUT;                  return E_INVALID_TIMEOUT;
65          }          }
66    
67          for (i=0; i < this->uThreadMax; i++)          if (this->SetLock(true) == 0)
68          {          {
69                  if (this->uThreadStatusList[i] == S_UNUSED)                  for (i=0; i < this->uThreadMax; i++)
70                  {                  {
71                          this->hThreadList[i] = hThread;                          if (this->uThreadStatusList[i] == S_UNUSED)
72                          this->uThreadStatusList[i] = S_WAITING;                          {
73                          this->thread_timeout[i] = thread_timeout;                                  this->ulThreadIdList[i] = ulThreadId;
74                          this->time_status_set[i] = clock();                                  this->uThreadStatusList[i] = S_WAITING;
75                          this->uThreadCount++;                                  this->thread_timeout[i] = thread_timeout;
76                          this->SetLock(false);                                  this->time_status_set[i] = clock();
77                          this->uLastErrorCode = E_NOERROR;                                  this->uThreadCount++;
78                          return E_NOERROR;                                  this->SetLock(false);
79                                    this->uLastErrorCode = E_NOERROR;
80                                    return E_NOERROR;
81                            }
82                  }                  }
83                    this->SetLock(false);
84                    this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
85                    return E_MAX_THREAD_EXCEEDED;
86          }          }
87    
88          this->SetLock(false);          return E_LOCK_TIMEOUT;
         this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;  
         return E_MAX_THREAD_EXCEEDED;  
89  }  }
90    
91  int thread_pool::SetLock(bool bLock, clock_t tTimeout)  int thread_pool::SetLock(bool bLock, clock_t tTimeout)
# Line 121  int thread_pool::GetLastError(void) cons Line 120  int thread_pool::GetLastError(void) cons
120          return this->uLastErrorCode;          return this->uLastErrorCode;
121  }  }
122    
123  int thread_pool::RemoveThread(HANDLE hThread)  int thread_pool::RemoveThread(ULONG ulThreadId)
124  {  {
125          UINT i;          UINT i;
126    
         if (this->SetLock(true) != 0)  
         {  
                 return this->uLastErrorCode;  
         }  
   
127          if (this->uThreadCount <= 0)          if (this->uThreadCount <= 0)
128          {          {
                 this->SetLock(false);  
129                  this->uLastErrorCode = E_THREAD_NOT_FOUND;                  this->uLastErrorCode = E_THREAD_NOT_FOUND;
130                  return E_THREAD_NOT_FOUND;                  return E_THREAD_NOT_FOUND;
131          }          }
132    
133          for (i=0; i < this->uThreadMax; i++)          if (this->SetLock(true) == 0)
134          {          {
135                  if (this->hThreadList[i] == hThread)                  for (i=0; i < this->uThreadMax; i++)
136                  {                  {
137                          this->hThreadList[i] = NULL;                          if (this->ulThreadIdList[i] == ulThreadId)
138                          this->uThreadCount--;                          {
139                          this->SetLock(false);                                  this->ulThreadIdList[i] = 0;
140                          this->uLastErrorCode = E_NOERROR;                                  this->uThreadStatusList[i] = S_UNUSED;
141                          return this->uLastErrorCode;                                  this->uThreadCount--;
142                                    this->SetLock(false);
143                                    this->uLastErrorCode = E_NOERROR;
144                                    return E_NOERROR;
145                            }
146                  }                  }
147                    this->SetLock(false);
148                    this->uLastErrorCode = E_THREAD_NOT_FOUND;
149                    return E_THREAD_NOT_FOUND;
150          }          }
151    
152          this->SetLock(false);          return E_LOCK_TIMEOUT;
         this->uLastErrorCode = E_THREAD_NOT_FOUND;  
         return E_THREAD_NOT_FOUND;  
153  }  }
154    
155    
156  int thread_pool::SetThreadStatus(HANDLE hThread, int uStatus)  int thread_pool::SetThreadStatus(ULONG ulThreadd, int uStatus)
157  {  {
158          UINTT i;          UINTT i;
159    
         if (this->SetLock(true) != 0)  
         {  
                 return this->uLastErrorCode;  
         }  
   
160          if (this->uThreadCount <= 0)          if (this->uThreadCount <= 0)
161          {          {
                 this->SetLock(false);  
162                  this->uLastErrorCode = E_THREAD_NOT_FOUND;                  this->uLastErrorCode = E_THREAD_NOT_FOUND;
163                  return E_THREAD_NOT_FOUND;                  return E_THREAD_NOT_FOUND;
164          }          }
165    
166          for (i=0; i < this->uThreadMax; i++)          for (i=0; i < this->uThreadMax; i++)
167          {          {
168                  if (this->hThreadList[i] == hThread)                  if (this->ulThreadIdList[i] == ulThreadId)
169                  {                  {
170                          this->uThreadStatusList[i] = (thread_status)uStatus;                          this->uThreadStatusList[i] = (thread_status)uStatus;
171                          this->time_status_set[i] = clock();                          this->time_status_set[i] = clock();
                         this->SetLock(false);  
172                          this->uLastErrorCode = E_NOERROR;                          this->uLastErrorCode = E_NOERROR;
173                          return this->uLastErrorCode;                          return this->uLastErrorCode;
174                  }                  }
175          }          }
176    
         this->SetLock(false);  
177          this->uLastErrorCode = E_THREAD_NOT_FOUND;          this->uLastErrorCode = E_THREAD_NOT_FOUND;
178          return E_THREAD_NOT_FOUND;          return E_THREAD_NOT_FOUND;
179  }  }
180    
181  int thread_pool::GetThreadStatus(HANDLE hThread)  int thread_pool::GetThreadStatus(ULONG ulThreadId)
182  {  {
183          UINT i;          UINT i;
184    
# Line 200  int thread_pool::GetThreadStatus(HANDLE Line 190  int thread_pool::GetThreadStatus(HANDLE
190    
191          for (i=0; i < this->uThreadMax; i++)          for (i=0; i < this->uThreadMax; i++)
192          {          {
193                  if (this->hThreadList[i] == hThread)                  if (this->ulThreadIdList[i] == ulThreadId)
194                  {                  {
195                          this->uLastErrorCode = E_NOERROR;                          this->uLastErrorCode = E_NOERROR;
196                          return this->uThreadStatusList[i];                          return this->uThreadStatusList[i];
# Line 215  DWORD thread_pool::KillDeadThread(LPVOID Line 205  DWORD thread_pool::KillDeadThread(LPVOID
205  {  {
206          thread_pool *p;          thread_pool *p;
207      UINT i;      UINT i;
208            HANDLE hThread;
209            ULONG ulThreadId;
210          int t_count = 0;          int t_count = 0;
211    
212          p = (thread_pool*)pParam;          p = (thread_pool*)pParam;
213    
214            p->ulThreadKillerId = GetCurrentThreadId();
215    
216          while(!p->bTerminateThreadKiller)          while(!p->bTerminateThreadKiller)
217          {          {
218                  if (t_count>=100)                  if (t_count>=100)
219                  {                  {
220                          t_count=0;                          t_count=0;
221    
222                          if (p->SetLock(true) == 0)                          for (i=0; i < p->uThreadMax; i++)
223                          {                          {
224                                  for (i=0; i < p->uThreadMax; i++)                                  if ((p->ulThreadIdList[i] != 0) &&
225                                            (p->uThreadStatusList[i] == S_WORKING) &&
226                                            (clock() - p->time_status_set[i] > p->thread_timeout[i]))
227                                  {                                  {
228                                          if ((p->hThreadList[i] != NULL) &&                                          ulThreadId = p->ulThreadIdList[i];
229                                                  (p->uThreadStatusList[i] == S_WORKING) &&                                          // Remove dead thread from thread pool
230                                                  (clock() - p->time_status_set[i] > p->thread_timeout[i]))                                          if (p->RemoveThread(ulThreadId) != 0)
231                                            {
232                                                    syslog << logfile::log_head << "Unregister thread ... Failed" << endl;
233                                            }
234                                            // Kill dead thread
235                                            if ((hThread = OpenThread(THREAD_TERMINATE,FALSE,ulThreadId)) == NULL)
236                                            {
237                                                    syslog << logfile::log_head << "Get thread handle error in KillDeadThread()" << endl;
238                                            }
239                                            else
240                                          {                                          {
241                                                  if (TerminateThread(p->hThreadList[i],-1))                                                  if (TerminateThread(hThread,-1))
242                                                  {                                                  {
243                                                          syslog << logfile::log_head << "Terminate dead thread ... OK" << endl;                                                          syslog << logfile::log_head << "Terminate dead thread ... OK" << endl;
244                                                  }                                                  }
# Line 241  DWORD thread_pool::KillDeadThread(LPVOID Line 246  DWORD thread_pool::KillDeadThread(LPVOID
246                                                  {                                                  {
247                                                          syslog << logfile::log_head << "Terminate dead thread ... Failed" << endl;                                                          syslog << logfile::log_head << "Terminate dead thread ... Failed" << endl;
248                                                  }                                                  }
249                                                  p->hThreadList[i] = NULL;                                                  CloseHandle(hThread);
                                                 p->uThreadStatusList[i] = S_UNUSED;  
                                                 p->time_status_set[i] = clock();  
                                                 p->uThreadCount--;  
250                                          }                                          }
251                                  }                                  }
252                          }                          }
           
                         p->SetLock(false);  
253                  }                  }
254    
255                  Sleep(100);                  Sleep(100);
256                  t_count++;                  t_count++;
257          }          }
258    
259            p->bTerminateThreadKiller = false;
260            p->ulThreadKillerId = 0;
261    
262          return (E_NOERROR);          return (E_NOERROR);
263  }  }
264    
# Line 272  int thread_pool::EnableKillDeadThread(vo Line 275  int thread_pool::EnableKillDeadThread(vo
275          this->bTerminateThreadKiller = false;          this->bTerminateThreadKiller = false;
276          if (hThreadCurrent = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread_pool::KillDeadThread,(LPVOID)this,0,&ulThreadId))          if (hThreadCurrent = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread_pool::KillDeadThread,(LPVOID)this,0,&ulThreadId))
277          {          {
                 this->hThreadKiller = hThreadCurrent;  
278                  syslog << logfile::log_head << "Create killer thread ... OK" << endl;                  syslog << logfile::log_head << "Create killer thread ... OK" << endl;
279          }          }
280          else          else
281          {          {
282                  syslog << logfile::log_head << "Create killer thread ... Failed" << endl;                  syslog << logfile::log_head << "Create killer thread ... Failed" << endl;
283                  return -1;                  this->uLastErrorCode = E_KILLER_BEGIN_FAILED;
284                    return E_KILLER_BEGIN_FAILED;
285          }          }
286    
287          return 0;          this->uLastErrorCode = E_NOERROR;
288            return E_NOERROR;
289  }  }
290    
291  int thread_pool::DisableKillDeadThread(void)  int thread_pool::DisableKillDeadThread(void)
292  {  {
293          bTerminateThreadKiller = true;          HANDLE hThread;
294    
295            if (this->ulThreadKillerId == 0)
296            {
297                    this->uLastErrorCode = E_KILLER_END_FAILED;
298                    return E_KILLER_END_FAILED;
299            }
300    
301            this->bTerminateThreadKiller = true;
302    
303          Sleep(1000);          Sleep(1000);
304    
305          if (!bTerminateThreadKiller)          if (!this->bTerminateThreadKiller)
306          {          {
307                  syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;                  syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
308          }          }
309            else
         if (bTerminateThreadKiller && this->hThreadKiller)  
310          {          {
311                  if (TerminateThread(this->hThreadKiller,0))                  if ((hThread = OpenThread(THREAD_TERMINATE,FALSE,this->ulThreadKillerId)) == NULL)
312                  {                  {
313                          this->hThreadKiller = NULL;                          syslog << logfile::log_head << "Get thread handle error in DisableKillDeadThread()" << endl;
314                          syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;                          this->uLastErrorCode = E_INVALID_THREAD;
315                            return E_INVALID_THREAD;
316                  }                  }
317                  else                  if (this->SetLock(true) == 0)
318                  {                  {
319                          syslog << logfile::log_head << "Terminate killer thread ... Failed" << endl;                          if (TerminateThread(hThread,0))
320                          return -1;                          {
321                                    CloseHandle(hThread);
322                                    this->ulThreadKillerId = 0;
323                                    this->SetLock(false);
324                                    syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
325                                    this->uLastErrorCode = E_NOERROR;
326                                    return E_NOERROR;
327                            }
328                  }                  }
329                    CloseHandle(hThread);
330                    this->SetLock(false);
331                    syslog << logfile::log_head << "Terminate killer thread ... Failed" << endl;
332                    this->uLastErrorCode = E_KILLER_END_FAILED;
333                    return E_KILLER_END_FAILED;
334          }          }
335          return 0;  
336            this->uLastErrorCode = E_NOERROR;
337            return E_NOERROR;
338    }
339    
340    int thread_pool::KillAllThread(void)
341    {
342            UINT i;
343            ULONG ulThreadId;
344            HANDLE hThread;
345    
346            for (i=0; i < this->uThreadMax; i++)
347            {
348                    if ((this->ulThreadIdList[i] != 0))
349                    {
350                            ulThreadId = this->ulThreadIdList[i];
351                            // Remove dead thread from thread pool
352                            if (this->RemoveThread(ulThreadId) != 0)
353                            {
354                                    syslog << logfile::log_head << "Unregister thread ... Failed" << endl;
355                            }
356                            // Kill dead thread
357                            if ((hThread = OpenThread(THREAD_TERMINATE,FALSE,ulThreadId)) == NULL)
358                            {
359                                    syslog << logfile::log_head << "Get thread handle error in KillAllThread()" << endl;
360                            }
361                            else
362                            {
363                                    if (TerminateThread(hThread,-1))
364                                    {
365                                            syslog << logfile::log_head << "Terminate all thread ... OK" << endl;
366                                    }
367                                    else
368                                    {
369                                            syslog << logfile::log_head << "Terminate all thread ... Failed" << endl;
370                                    }
371                                    CloseHandle(hThread);
372                            }
373                    }
374            }
375    
376            this->uLastErrorCode = E_NOERROR;
377            return E_NOERROR;
378  }  }

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1