LeafOK_CVS/innwebd/thread_pool.cpp

/*******************************************************/
/*                                                     */
/*  LeafOK Innd                                        */
/*  Copyright (C) LeafOK.com, 2003-2004                */
/*                                                     */
/*  Programmed by Leaf                                 */
/*  E-mail:leaf@leafok.com  QQ:6049044                 */
/*                                                     */
/*  http://bbs.leafok.com                              */
/*  http://bbs.leafok.net                              */
/*  http://bbs.fenglin.info                            */
/*                                                     */
/*******************************************************/

#include "StdAfx.h"
#include ".\thread_pool.h"

thread_pool::thread_pool(UINT uThreadMax)
{
        UINT i;

        this->uLastErrorCode = E_NOERROR;
        this->uThreadCount = 0;
        this->uThreadMax = uThreadMax;
        this->hThreadKiller = NULL;

        if (this->uThreadMax > TS_MAX_THREAD)
        {
                this->uThreadMax = 0;
                this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
        }

        for (i=0; i < this->uThreadMax; i++)
        {
                this->hThreadList[i] = NULL;
                this->uThreadStatusList[i] = S_UNUSED;
                this->time_status_set[i] = clock();
        }

        this->SetLock(false);

        this->EnableKillDeadThread();
}

thread_pool::~thread_pool(void)
{
        this->DisableKillDeadThread();
}

int thread_pool::AddThread(HANDLE hThread, clock_t thread_timeout)
{
        UINT i;

        if (this->SetLock(true) != 0)
        {
                return this->uLastErrorCode;
        }

        if (this->uThreadCount >= this->uThreadMax)
        {
                this->SetLock(false);
                this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
                return E_MAX_THREAD_EXCEEDED;
        }

        if (thread_timeout < 0)
        {
                this->uLastErrorCode = E_INVALID_TIMEOUT;
                return E_INVALID_TIMEOUT;
        }

        for (i=0; i < this->uThreadMax; i++)
        {
                if (this->uThreadStatusList[i] == S_UNUSED)
                {
                        this->hThreadList[i] = hThread;
                        this->uThreadStatusList[i] = S_WAITING;
                        this->thread_timeout[i] = thread_timeout;
                        this->time_status_set[i] = clock();
                        this->uThreadCount++;
                        this->SetLock(false);
                        this->uLastErrorCode = E_NOERROR;
                        return E_NOERROR;
                }
        }

        this->SetLock(false);
        this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
        return E_MAX_THREAD_EXCEEDED;
}

int thread_pool::SetLock(bool bLock, clock_t tTimeout)
{
        clock_t wait = 0;
    
        if (!bLock) // Free lock
        {
                this->bProcessLock = false;
                this->uLastErrorCode = E_NOERROR;
                return E_NOERROR;
        }

        while (this->bProcessLock) // Locked by others
        {
                Sleep(10);
                wait += 10;
                if (wait > tTimeout) // Timeout
                {
                        this->uLastErrorCode = E_LOCK_TIMEOUT;
                        return E_LOCK_TIMEOUT;
                }
        }
        this->bProcessLock = true;
        this->uLastErrorCode = E_NOERROR;

        return E_NOERROR;
}

int thread_pool::GetLastError(void) const
{
        return this->uLastErrorCode;
}

int thread_pool::RemoveThread(HANDLE hThread)
{
        UINT i;

        if (this->SetLock(true) != 0)
        {
                return this->uLastErrorCode;
        }

        if (this->uThreadCount <= 0)
        {
                this->SetLock(false);
                this->uLastErrorCode = E_THREAD_NOT_FOUND;
                return E_THREAD_NOT_FOUND;
        }

        for (i=0; i < this->uThreadMax; i++)
        {
                if (this->hThreadList[i] == hThread)
                {
                        this->hThreadList[i] = NULL;
                        this->uThreadCount--;
                        this->SetLock(false);
                        this->uLastErrorCode = E_NOERROR;
                        return this->uLastErrorCode;
                }
        }

        this->SetLock(false);
        this->uLastErrorCode = E_THREAD_NOT_FOUND;
        return E_THREAD_NOT_FOUND;
}


int thread_pool::SetThreadStatus(HANDLE hThread, int uStatus)
{
        UINTT i;

        if (this->SetLock(true) != 0)
        {
                return this->uLastErrorCode;
        }

        if (this->uThreadCount <= 0)
        {
                this->SetLock(false);
                this->uLastErrorCode = E_THREAD_NOT_FOUND;
                return E_THREAD_NOT_FOUND;
        }

        for (i=0; i < this->uThreadMax; i++)
        {
                if (this->hThreadList[i] == hThread)
                {
                        this->uThreadStatusList[i] = (thread_status)uStatus;
                        this->time_status_set[i] = clock();
                        this->SetLock(false);
                        this->uLastErrorCode = E_NOERROR;
                        return this->uLastErrorCode;
                }
        }

        this->SetLock(false);
        this->uLastErrorCode = E_THREAD_NOT_FOUND;
        return E_THREAD_NOT_FOUND;
}

int thread_pool::GetThreadStatus(HANDLE hThread)
{
        UINT i;

        if (this->uThreadCount <= 0)
        {
                this->uLastErrorCode = E_THREAD_NOT_FOUND;
                return S_UNKNOWN;
        }

        for (i=0; i < this->uThreadMax; i++)
        {
                if (this->hThreadList[i] == hThread)
                {
                        this->uLastErrorCode = E_NOERROR;
                        return this->uThreadStatusList[i];
                }
        }

        this->uLastErrorCode = E_THREAD_NOT_FOUND;
        return S_UNKNOWN;
}

DWORD thread_pool::KillDeadThread(LPVOID pParam)
{
        thread_pool *p;
    UINT i;
    bool bKillStatus = true;

        p = (thread_pool*)pParam;

        if (p->SetLock(true) != 0)
        {
                return p->uLastErrorCode;
        }

        if (p->uThreadCount <= 0)
        {
                p->SetLock(false);
                p->uLastErrorCode = E_THREAD_NOT_FOUND;
                return E_THREAD_NOT_FOUND;
        }

        for (i=0; i < p->uThreadMax; i++)
        {
                if ((p->uThreadStatusList[i] == S_WORKING) && 
                        (clock() - p->time_status_set[i] > p->thread_timeout[i]))
                {
                        if (TerminateThread(p->hThreadList[i],-1))
                        {
                                bKillStatus &= true;
                                syslog << logfile::log_head << "Terminate dead thread ... OK" << endl;
                        }
                        else
                        {
                                bKillStatus &= false;
                                syslog << logfile::log_head << "Terminate dead thread ... Failed" << endl;
                        }
                        p->hThreadList[i] = NULL;
                        p->uThreadStatusList[i] = S_UNUSED;
                        p->time_status_set[i] = clock();
                        p->uThreadCount--;
                }
        }

        p->SetLock(false);
        p->uLastErrorCode = (bKillStatus?E_NOERROR:E_KILL_THREAD_FAILED);
        return (bKillStatus?E_NOERROR:E_KILL_THREAD_FAILED);
}

int thread_pool::GetThreadCount(void) const
{
        return this->uThreadCount;
}

int thread_pool::EnableKillDeadThread(void)
{
        HANDLE hThreadCurrent;
        ULONG ulThreadId;
        if (hThreadCurrent = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread_pool::KillDeadThread,(LPVOID)this,0,&ulThreadId))
        {
                this->hThreadKiller = hThreadCurrent;
                syslog << logfile::log_head << "Create killer thread ... OK" << endl;
        }
        else
        {
                syslog << logfile::log_head << "Create killer thread ... Failed" << endl;
                return -1;
        }

        return 0;
}

int thread_pool::DisableKillDeadThread(void)
{
        if (this->hThreadKiller)
        {
                if (TerminateThread(this->hThreadKiller,0))
                {
                        this->hThreadKiller = NULL;
                        syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
                }
                else
                {
                        syslog << logfile::log_head << "Terminate killer thread ... Failed" << endl;
                        return -1;
                }
        }
        return 0;
}
1	sysadm	1.1	/*******************************************************/
2			/* */
3			/* LeafOK Innd */
4			/* Copyright (C) LeafOK.com, 2003-2004 */
5			/* */
6			/* Programmed by Leaf */
7			/* E-mail:leaf@leafok.com QQ:6049044 */
8			/* */
9			/* http://bbs.leafok.com */
10			/* http://bbs.leafok.net */
11			/* http://bbs.fenglin.info */
12			/* */
13			/*******************************************************/
14
15			#include "StdAfx.h"
16			#include ".\thread_pool.h"
17
18	sysadm	1.3	thread_pool::thread_pool(UINT uThreadMax)
19	sysadm	1.1	{
20			UINT i;
21
22			this->uLastErrorCode = E_NOERROR;
23			this->uThreadCount = 0;
24			this->uThreadMax = uThreadMax;
25	sysadm	1.3	this->hThreadKiller = NULL;
26	sysadm	1.1
27	sysadm	1.3	if (this->uThreadMax > TS_MAX_THREAD)
28	sysadm	1.2	{
29	sysadm	1.3	this->uThreadMax = 0;
30	sysadm	1.2	this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
31			}
32
33	sysadm	1.1	for (i=0; i < this->uThreadMax; i++)
34			{
35			this->hThreadList[i] = NULL;
36			this->uThreadStatusList[i] = S_UNUSED;
37	sysadm	1.2	this->time_status_set[i] = clock();
38	sysadm	1.1	}
39
40			this->SetLock(false);
41	sysadm	1.3
42			this->EnableKillDeadThread();
43	sysadm	1.1	}
44
45			thread_pool::~thread_pool(void)
46			{
47	sysadm	1.3	this->DisableKillDeadThread();
48	sysadm	1.1	}
49
50	sysadm	1.3	int thread_pool::AddThread(HANDLE hThread, clock_t thread_timeout)
51	sysadm	1.1	{
52			UINT i;
53
54	sysadm	1.3	if (this->SetLock(true) != 0)
55	sysadm	1.1	{
56			return this->uLastErrorCode;
57			}
58
59			if (this->uThreadCount >= this->uThreadMax)
60			{
61			this->SetLock(false);
62			this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
63			return E_MAX_THREAD_EXCEEDED;
64			}
65
66	sysadm	1.3	if (thread_timeout < 0)
67			{
68			this->uLastErrorCode = E_INVALID_TIMEOUT;
69			return E_INVALID_TIMEOUT;
70			}
71
72	sysadm	1.1	for (i=0; i < this->uThreadMax; i++)
73			{
74			if (this->uThreadStatusList[i] == S_UNUSED)
75			{
76			this->hThreadList[i] = hThread;
77	sysadm	1.2	this->uThreadStatusList[i] = S_WAITING;
78	sysadm	1.3	this->thread_timeout[i] = thread_timeout;
79	sysadm	1.2	this->time_status_set[i] = clock();
80	sysadm	1.1	this->uThreadCount++;
81			this->SetLock(false);
82			this->uLastErrorCode = E_NOERROR;
83			return E_NOERROR;
84			}
85			}
86
87			this->SetLock(false);
88			this->uLastErrorCode = E_MAX_THREAD_EXCEEDED;
89			return E_MAX_THREAD_EXCEEDED;
90			}
91
92	sysadm	1.2	int thread_pool::SetLock(bool bLock, clock_t tTimeout)
93	sysadm	1.1	{
94	sysadm	1.2	clock_t wait = 0;
95	sysadm	1.1
96			if (!bLock) // Free lock
97			{
98			this->bProcessLock = false;
99			this->uLastErrorCode = E_NOERROR;
100			return E_NOERROR;
101			}
102
103			while (this->bProcessLock) // Locked by others
104			{
105			Sleep(10);
106			wait += 10;
107			if (wait > tTimeout) // Timeout
108			{
109			this->uLastErrorCode = E_LOCK_TIMEOUT;
110			return E_LOCK_TIMEOUT;
111			}
112			}
113			this->bProcessLock = true;
114			this->uLastErrorCode = E_NOERROR;
115
116			return E_NOERROR;
117			}
118
119	sysadm	1.3	int thread_pool::GetLastError(void) const
120	sysadm	1.1	{
121			return this->uLastErrorCode;
122			}
123
124			int thread_pool::RemoveThread(HANDLE hThread)
125			{
126			UINT i;
127
128	sysadm	1.3	if (this->SetLock(true) != 0)
129	sysadm	1.1	{
130			return this->uLastErrorCode;
131			}
132
133			if (this->uThreadCount <= 0)
134			{
135			this->SetLock(false);
136			this->uLastErrorCode = E_THREAD_NOT_FOUND;
137			return E_THREAD_NOT_FOUND;
138			}
139
140			for (i=0; i < this->uThreadMax; i++)
141			{
142			if (this->hThreadList[i] == hThread)
143			{
144			this->hThreadList[i] = NULL;
145			this->uThreadCount--;
146			this->SetLock(false);
147			this->uLastErrorCode = E_NOERROR;
148			return this->uLastErrorCode;
149			}
150			}
151
152			this->SetLock(false);
153			this->uLastErrorCode = E_THREAD_NOT_FOUND;
154			return E_THREAD_NOT_FOUND;
155			}
156
157
158	sysadm	1.2	int thread_pool::SetThreadStatus(HANDLE hThread, int uStatus)
159	sysadm	1.1	{
160			UINTT i;
161
162	sysadm	1.3	if (this->SetLock(true) != 0)
163	sysadm	1.1	{
164			return this->uLastErrorCode;
165			}
166
167			if (this->uThreadCount <= 0)
168			{
169			this->SetLock(false);
170			this->uLastErrorCode = E_THREAD_NOT_FOUND;
171			return E_THREAD_NOT_FOUND;
172			}
173
174			for (i=0; i < this->uThreadMax; i++)
175			{
176			if (this->hThreadList[i] == hThread)
177			{
178			this->uThreadStatusList[i] = (thread_status)uStatus;
179	sysadm	1.2	this->time_status_set[i] = clock();
180	sysadm	1.1	this->SetLock(false);
181			this->uLastErrorCode = E_NOERROR;
182			return this->uLastErrorCode;
183			}
184			}
185
186			this->SetLock(false);
187			this->uLastErrorCode = E_THREAD_NOT_FOUND;
188			return E_THREAD_NOT_FOUND;
189			}
190
191	sysadm	1.2	int thread_pool::GetThreadStatus(HANDLE hThread)
192	sysadm	1.1	{
193			UINT i;
194
195			if (this->uThreadCount <= 0)
196			{
197			this->uLastErrorCode = E_THREAD_NOT_FOUND;
198			return S_UNKNOWN;
199			}
200
201			for (i=0; i < this->uThreadMax; i++)
202			{
203			if (this->hThreadList[i] == hThread)
204			{
205			this->uLastErrorCode = E_NOERROR;
206			return this->uThreadStatusList[i];
207			}
208			}
209
210			this->uLastErrorCode = E_THREAD_NOT_FOUND;
211			return S_UNKNOWN;
212			}
213	sysadm	1.2
214	sysadm	1.3	DWORD thread_pool::KillDeadThread(LPVOID pParam)
215	sysadm	1.2	{
216	sysadm	1.3	thread_pool *p;
217			UINT i;
218			bool bKillStatus = true;
219
220			p = (thread_pool*)pParam;
221	sysadm	1.2
222	sysadm	1.3	if (p->SetLock(true) != 0)
223	sysadm	1.2	{
224	sysadm	1.3	return p->uLastErrorCode;
225	sysadm	1.2	}
226
227	sysadm	1.3	if (p->uThreadCount <= 0)
228	sysadm	1.2	{
229	sysadm	1.3	p->SetLock(false);
230			p->uLastErrorCode = E_THREAD_NOT_FOUND;
231	sysadm	1.2	return E_THREAD_NOT_FOUND;
232			}
233
234	sysadm	1.3	for (i=0; i < p->uThreadMax; i++)
235	sysadm	1.2	{
236	sysadm	1.3	if ((p->uThreadStatusList[i] == S_WORKING) &&
237			(clock() - p->time_status_set[i] > p->thread_timeout[i]))
238	sysadm	1.2	{
239	sysadm	1.3	if (TerminateThread(p->hThreadList[i],-1))
240	sysadm	1.2	{
241			bKillStatus &= true;
242			syslog << logfile::log_head << "Terminate dead thread ... OK" << endl;
243			}
244			else
245			{
246			bKillStatus &= false;
247			syslog << logfile::log_head << "Terminate dead thread ... Failed" << endl;
248			}
249	sysadm	1.3	p->hThreadList[i] = NULL;
250			p->uThreadStatusList[i] = S_UNUSED;
251			p->time_status_set[i] = clock();
252			p->uThreadCount--;
253	sysadm	1.2	}
254			}
255
256	sysadm	1.3	p->SetLock(false);
257			p->uLastErrorCode = (bKillStatus?E_NOERROR:E_KILL_THREAD_FAILED);
258	sysadm	1.2	return (bKillStatus?E_NOERROR:E_KILL_THREAD_FAILED);
259			}
260	sysadm	1.3
261			int thread_pool::GetThreadCount(void) const
262			{
263			return this->uThreadCount;
264			}
265
266			int thread_pool::EnableKillDeadThread(void)
267			{
268			HANDLE hThreadCurrent;
269			ULONG ulThreadId;
270			if (hThreadCurrent = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread_pool::KillDeadThread,(LPVOID)this,0,&ulThreadId))
271			{
272			this->hThreadKiller = hThreadCurrent;
273			syslog << logfile::log_head << "Create killer thread ... OK" << endl;
274			}
275			else
276			{
277			syslog << logfile::log_head << "Create killer thread ... Failed" << endl;
278			return -1;
279			}
280
281			return 0;
282			}
283
284			int thread_pool::DisableKillDeadThread(void)
285			{
286			if (this->hThreadKiller)
287			{
288			if (TerminateThread(this->hThreadKiller,0))
289			{
290			this->hThreadKiller = NULL;
291			syslog << logfile::log_head << "Terminate killer thread ... OK" << endl;
292			}
293			else
294			{
295			syslog << logfile::log_head << "Terminate killer thread ... Failed" << endl;
296			return -1;
297			}
298			}
299			return 0;
300			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1