/[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.1 by sysadm, Sat Jul 3 08:38:54 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, double 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->uThreadMax > TS_MAX_THREAD)
28            {
29                    this->uThreadMax = 0;
30                    this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
31            }
32    
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;
36                  this->uThreadStatusList[i] = S_UNUSED;                  this->uThreadStatusList[i] = S_UNUSED;
37                  this->time_status_keep[i] = 0;                  this->time_status_set[i] = clock();
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 55  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;
78                            this->thread_timeout[i] = thread_timeout;
79                            this->time_status_set[i] = clock();
80                          this->uThreadCount++;                          this->uThreadCount++;
81                          this->SetLock(false);                          this->SetLock(false);
82                          this->uLastErrorCode = E_NOERROR;                          this->uLastErrorCode = E_NOERROR;
# Line 72  int thread_pool::AddThread(HANDLE hThrea Line 89  int thread_pool::AddThread(HANDLE hThrea
89          return E_MAX_THREAD_EXCEEDED;          return E_MAX_THREAD_EXCEEDED;
90  }  }
91    
92  int thread_pool::SetLock(bool bLock, time_t tTimeout)  int thread_pool::SetLock(bool bLock, clock_t tTimeout)
93  {  {
94          time_t wait = 0;          clock_t wait = 0;
95            
96          if (!bLock) // Free lock          if (!bLock) // Free lock
97          {          {
# Line 99  int thread_pool::SetLock(bool bLock, tim Line 116  int thread_pool::SetLock(bool bLock, tim
116          return E_NOERROR;          return E_NOERROR;
117  }  }
118    
119  UINT thread_pool::GetLastError(void)  int thread_pool::GetLastError(void) const
120  {  {
121          return this->uLastErrorCode;          return this->uLastErrorCode;
122  }  }
# Line 108  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 138  int thread_pool::RemoveThread(HANDLE hTh Line 155  int thread_pool::RemoveThread(HANDLE hTh
155  }  }
156    
157    
158  int thread_pool::SetThreadStatus(HANDLE hThread, UINT uStatus)  int thread_pool::SetThreadStatus(HANDLE hThread, int uStatus)
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 159  int thread_pool::SetThreadStatus(HANDLE Line 176  int thread_pool::SetThreadStatus(HANDLE
176                  if (this->hThreadList[i] == hThread)                  if (this->hThreadList[i] == hThread)
177                  {                  {
178                          this->uThreadStatusList[i] = (thread_status)uStatus;                          this->uThreadStatusList[i] = (thread_status)uStatus;
179                            this->time_status_set[i] = clock();
180                          this->SetLock(false);                          this->SetLock(false);
181                          this->uLastErrorCode = E_NOERROR;                          this->uLastErrorCode = E_NOERROR;
182                          return this->uLastErrorCode;                          return this->uLastErrorCode;
# Line 170  int thread_pool::SetThreadStatus(HANDLE Line 188  int thread_pool::SetThreadStatus(HANDLE
188          return E_THREAD_NOT_FOUND;          return E_THREAD_NOT_FOUND;
189  }  }
190    
191  UINT thread_pool::GetThreadStatus(HANDLE hThread)  int thread_pool::GetThreadStatus(HANDLE hThread)
192  {  {
193          UINT i;          UINT i;
194    
# Line 192  UINT thread_pool::GetThreadStatus(HANDLE Line 210  UINT thread_pool::GetThreadStatus(HANDLE
210          this->uLastErrorCode = E_THREAD_NOT_FOUND;          this->uLastErrorCode = E_THREAD_NOT_FOUND;
211          return S_UNKNOWN;          return S_UNKNOWN;
212  }  }
213    
214    DWORD thread_pool::KillDeadThread(LPVOID pParam)
215    {
216            thread_pool *p;
217        UINT i;
218            int t_count = 0;
219    
220            p = (thread_pool*)pParam;
221    
222            while(!p->bTerminateThreadKiller)
223            {
224                    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            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->hThreadKiller = hThreadCurrent;
276                    syslog << logfile::log_head << "Create killer thread ... OK" << endl;
277            }
278            else
279            {
280                    syslog << logfile::log_head << "Create killer thread ... Failed" << endl;
281                    return -1;
282            }
283    
284            return 0;
285    }
286    
287    int thread_pool::DisableKillDeadThread(void)
288    {
289            bTerminateThreadKiller = true;
290    
291            Sleep(1000);
292    
293            if (!bTerminateThreadKiller)
294            {
295                    syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
296            }
297    
298            if (bTerminateThreadKiller && this->hThreadKiller)
299            {
300                    if (TerminateThread(this->hThreadKiller,0))
301                    {
302                            this->hThreadKiller = NULL;
303                            syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
304                    }
305                    else
306                    {
307                            syslog << logfile::log_head << "Terminate killer thread ... Failed" << endl;
308                            return -1;
309                    }
310            }
311            return 0;
312    }

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