/[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.2 by sysadm, Sat Jul 3 09:37:58 2004 UTC Revision 1.4 by sysadm, Sat Jul 3 15:10:23 2004 UTC
# Line 15  Line 15 
15  #include "StdAfx.h"  #include "StdAfx.h"
16  #include ".\thread_pool.h"  #include ".\thread_pool.h"
17    
18  thread_pool::thread_pool(UINT uThreadMax, clock_t thread_timeout)  thread_pool::thread_pool(UINT uThreadMax)
19  {  {
20          UINT i;          UINT i;
21    
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->thread_timeout = thread_timeout;          this->hThreadKiller = NULL;
26    
27          if (this->uThreadCount > TS_MAX_THREAD)          if (this->uThreadMax > TS_MAX_THREAD)
28          {          {
29                  this->uThreadCount = 0;                  this->uThreadMax = 0;
30                  this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;                  this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
31          }          }
32    
         if (this->thread_timeout < 0 || this->thread_timeout > TS_SETLOCK_TIMEOUT_MAX)  
         {  
                 this->thread_timeout = TS_SETLOCK_TIMEOUT;  
                 this->uLastErrorCode = E_INVALID_TIMEOUT;  
         }  
   
33          for (i=0; i < this->uThreadMax; i++)          for (i=0; i < this->uThreadMax; i++)
34          {          {
35                  this->hThreadList[i] = NULL;                  this->hThreadList[i] = NULL;
# Line 44  thread_pool::thread_pool(UINT uThreadMax Line 38  thread_pool::thread_pool(UINT uThreadMax
38          }          }
39    
40          this->SetLock(false);          this->SetLock(false);
41    
42            this->EnableKillDeadThread();
43  }  }
44    
45  thread_pool::~thread_pool(void)  thread_pool::~thread_pool(void)
46  {  {
47            this->DisableKillDeadThread();
48  }  }
49    
50  int thread_pool::AddThread(HANDLE hThread)  int thread_pool::AddThread(HANDLE hThread, clock_t thread_timeout)
51  {  {
52          UINT i;          UINT i;
53    
54          if (this->SetLock(true) == 0)          if (this->SetLock(true) != 0)
55          {          {
56                  return this->uLastErrorCode;                  return this->uLastErrorCode;
57          }          }
# Line 66  int thread_pool::AddThread(HANDLE hThrea Line 63  int thread_pool::AddThread(HANDLE hThrea
63                  return E_MAX_THREAD_EXCEEDED;                  return E_MAX_THREAD_EXCEEDED;
64          }          }
65    
66            if (thread_timeout < 0)
67            {
68                    this->uLastErrorCode = E_INVALID_TIMEOUT;
69                    return E_INVALID_TIMEOUT;
70            }
71    
72          for (i=0; i < this->uThreadMax; i++)          for (i=0; i < this->uThreadMax; i++)
73          {          {
74                  if (this->uThreadStatusList[i] == S_UNUSED)                  if (this->uThreadStatusList[i] == S_UNUSED)
75                  {                  {
76                          this->hThreadList[i] = hThread;                          this->hThreadList[i] = hThread;
77                          this->uThreadStatusList[i] = S_WAITING;                          this->uThreadStatusList[i] = S_WAITING;
78                            this->thread_timeout[i] = thread_timeout;
79                          this->time_status_set[i] = clock();                          this->time_status_set[i] = clock();
80                          this->uThreadCount++;                          this->uThreadCount++;
81                          this->SetLock(false);                          this->SetLock(false);
# Line 112  int thread_pool::SetLock(bool bLock, clo Line 116  int thread_pool::SetLock(bool bLock, clo
116          return E_NOERROR;          return E_NOERROR;
117  }  }
118    
119  int thread_pool::GetLastError(void)  int thread_pool::GetLastError(void) const
120  {  {
121          return this->uLastErrorCode;          return this->uLastErrorCode;
122  }  }
# Line 121  int thread_pool::RemoveThread(HANDLE hTh Line 125  int thread_pool::RemoveThread(HANDLE hTh
125  {  {
126          UINT i;          UINT i;
127    
128          if (this->SetLock(true) == 0)          if (this->SetLock(true) != 0)
129          {          {
130                  return this->uLastErrorCode;                  return this->uLastErrorCode;
131          }          }
# Line 155  int thread_pool::SetThreadStatus(HANDLE Line 159  int thread_pool::SetThreadStatus(HANDLE
159  {  {
160          UINTT i;          UINTT i;
161    
162          if (this->SetLock(true) == 0)          if (this->SetLock(true) != 0)
163          {          {
164                  return this->uLastErrorCode;                  return this->uLastErrorCode;
165          }          }
# Line 207  int thread_pool::GetThreadStatus(HANDLE Line 211  int thread_pool::GetThreadStatus(HANDLE
211          return S_UNKNOWN;          return S_UNKNOWN;
212  }  }
213    
214  int thread_pool::KillDeadThread(void)  DWORD thread_pool::KillDeadThread(LPVOID pParam)
215  {  {
216          UINT i;          thread_pool *p;
217          bool bKillStatus = true;      UINT i;
218            int t_count = 0;
219    
220          if (this->SetLock(true) == 0)          p = (thread_pool*)pParam;
221    
222            while(!p->bTerminateThreadKiller)
223          {          {
224                  return this->uLastErrorCode;                  if (t_count>=100)
225                    {
226                            t_count=0;
227    
228                            if (p->SetLock(true) == 0)
229                            {
230                                    for (i=0; i < p->uThreadMax; i++)
231                                    {
232                                            if ((p->hThreadList[i] != NULL) &&
233                                                    (p->uThreadStatusList[i] == S_WORKING) &&
234                                                    (clock() - p->time_status_set[i] > p->thread_timeout[i]))
235                                            {
236                                                    if (TerminateThread(p->hThreadList[i],-1))
237                                                    {
238                                                            syslog << logfile::log_head << "Terminate dead thread ... OK" << endl;
239                                                    }
240                                                    else
241                                                    {
242                                                            syslog << logfile::log_head << "Terminate dead thread ... Failed" << endl;
243                                                    }
244                                                    p->hThreadList[i] = NULL;
245                                                    p->uThreadStatusList[i] = S_UNUSED;
246                                                    p->time_status_set[i] = clock();
247                                                    p->uThreadCount--;
248                                            }
249                                    }
250                            }
251            
252                            p->SetLock(false);
253                    }
254    
255                    Sleep(100);
256                    t_count++;
257          }          }
258    
259          if (this->uThreadCount <= 0)          return (E_NOERROR);
260    }
261    
262    int thread_pool::GetThreadCount(void) const
263    {
264            return this->uThreadCount;
265    }
266    
267    int thread_pool::EnableKillDeadThread(void)
268    {
269            HANDLE hThreadCurrent;
270            ULONG ulThreadId;
271    
272            this->bTerminateThreadKiller = false;
273            if (hThreadCurrent = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread_pool::KillDeadThread,(LPVOID)this,0,&ulThreadId))
274          {          {
275                  this->SetLock(false);                  this->hThreadKiller = hThreadCurrent;
276                  this->uLastErrorCode = E_THREAD_NOT_FOUND;                  syslog << logfile::log_head << "Create killer thread ... OK" << endl;
277                  return E_THREAD_NOT_FOUND;          }
278            else
279            {
280                    syslog << logfile::log_head << "Create killer thread ... Failed" << endl;
281                    return -1;
282          }          }
283    
284          for (i=0; i < this->uThreadMax; i++)          return 0;
285    }
286    
287    int thread_pool::DisableKillDeadThread(void)
288    {
289            bTerminateThreadKiller = true;
290    
291            Sleep(1000);
292    
293            if (!bTerminateThreadKiller)
294          {          {
295                  if ((this->uThreadStatusList[i] == S_WORKING) &&                  syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
296                          (clock() - this->time_status_set[i] > this->thread_timeout))          }
297    
298            if (bTerminateThreadKiller && this->hThreadKiller)
299            {
300                    if (TerminateThread(this->hThreadKiller,0))
301                  {                  {
302                          if (TerminateThread(this->hThreadList[i],-1))                          this->hThreadKiller = NULL;
303                          {                          syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
304                                  bKillStatus &= true;                  }
305                                  syslog << logfile::log_head << "Terminate dead thread ... OK" << endl;                  else
306                          }                  {
307                          else                          syslog << logfile::log_head << "Terminate killer thread ... Failed" << endl;
308                          {                          return -1;
                                 bKillStatus &= false;  
                                 syslog << logfile::log_head << "Terminate dead thread ... Failed" << endl;  
                         }  
                         this->hThreadList[i] = NULL;  
                         this->uThreadStatusList[i] = S_UNUSED;  
                         this->time_status_set[i] = clock();  
                         this->uThreadCount--;  
309                  }                  }
310          }          }
311            return 0;
         this->SetLock(false);  
         this->uLastErrorCode = (bKillStatus?E_NOERROR:E_KILL_THREAD_FAILED);  
         return (bKillStatus?E_NOERROR:E_KILL_THREAD_FAILED);  
312  }  }

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