122 lines
3.3 KiB
C++
122 lines
3.3 KiB
C++
// ThinThread.cpp : implementation file
|
|
// Copyright (C) 1997 by The Windward Group, All Rights Reserved
|
|
|
|
#include "stdafx.h"
|
|
#include "ThinThread.h"
|
|
#include <process.h> /* _beginthread, _endthread */
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// ThinThread
|
|
CThinThread::CThinThread()
|
|
: m_b2ndThread(FALSE)
|
|
{
|
|
// Create a signaled, manual-reset event to synchronize destruction
|
|
m_pExitEvent = new CEvent();//TRUE, TRUE);
|
|
ASSERT(m_pExitEvent);
|
|
|
|
// Create a non-signaled, auto-reset event to wait on for work cycle
|
|
m_pWorkEvent = new CEvent();
|
|
ASSERT(m_pWorkEvent);
|
|
m_pWorkEvent2 = new CEvent();
|
|
ASSERT(m_pWorkEvent2);
|
|
}
|
|
|
|
BOOL CThinThread::CreateThread(DWORD dwCreateFlags,
|
|
UINT nStackSize,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttrs,
|
|
UINT nMilliSecs,
|
|
UINT Type)
|
|
{
|
|
m_bEndThread = FALSE;
|
|
m_nCycleTime = nMilliSecs;
|
|
m_pExitEvent->ResetEvent(); // exit event is reset until we're done
|
|
|
|
// Start second thread
|
|
ULONG usThreadAddr;
|
|
// m_hThread2 = reinterpret_cast<HANDLE> (_beginthreadex(lpSecurityAttrs, nStackSize, Start, this, 1, &usThreadAddr));
|
|
// return reinterpret_cast<unsigned long> (m_hThread2);
|
|
if(WORD_THREAD_WITH_HOGA == Type) {
|
|
m_b2ndThread = TRUE;
|
|
m_hThread2 = ::CreateThread(lpSecurityAttrs,nStackSize,Start,this,0,&usThreadAddr);
|
|
} else {
|
|
m_b3rdThread = TRUE;
|
|
m_hThread3 = ::CreateThread(lpSecurityAttrs,nStackSize,Start2,this,0,&usThreadAddr);
|
|
}
|
|
return reinterpret_cast<unsigned long> (m_hThread2);
|
|
}
|
|
|
|
CThinThread::~CThinThread()
|
|
{
|
|
delete m_pWorkEvent; m_pWorkEvent = NULL;
|
|
delete m_pWorkEvent2; m_pWorkEvent2 = NULL;
|
|
delete m_pExitEvent; m_pExitEvent = NULL;
|
|
}
|
|
|
|
void CThinThread::KillThread2()
|
|
{
|
|
// Start up the other thread so it can complete.
|
|
// When it does, it will set the exit event and the object can be destructed.
|
|
m_bEndThread = TRUE;
|
|
m_pWorkEvent->SetEvent();
|
|
m_pWorkEvent2->SetEvent();
|
|
|
|
Sleep(0);
|
|
|
|
CSingleLock csl(m_pExitEvent);
|
|
csl.Lock(); // wait for 2nd thread to finish
|
|
csl.Unlock();
|
|
}
|
|
|
|
void CThinThread::Finalize()
|
|
{
|
|
KillThread2();
|
|
}
|
|
|
|
int CThinThread::Run(UINT ThreadType)
|
|
{
|
|
CSingleLock *pcsl;
|
|
if(WORD_THREAD_WITH_HOGA == ThreadType)
|
|
pcsl = new CSingleLock(m_pWorkEvent); // synch on the work event
|
|
else if(WORD_THREAD_WITHOUT_HOGA == ThreadType)
|
|
pcsl = new CSingleLock(m_pWorkEvent2); // synch on the work event2
|
|
else
|
|
ASSERT(FALSE);
|
|
|
|
StartWork(); // do derived startup
|
|
|
|
while (!m_bEndThread) // loop until we're done
|
|
{
|
|
pcsl->Lock(m_nCycleTime); // wait for event or timeout
|
|
pcsl->Unlock();
|
|
if (!m_bEndThread)
|
|
DoWork(ThreadType); // then do derived work
|
|
}
|
|
|
|
m_pExitEvent->SetEvent(); // set not waiting signal
|
|
|
|
if(WORD_THREAD_WITH_HOGA == ThreadType)
|
|
m_b2ndThread = FALSE;
|
|
else
|
|
m_b3rdThread = FALSE;
|
|
|
|
delete pcsl;
|
|
EndWork(); // do derived shutdown
|
|
|
|
// _endthreadex(0);
|
|
// ExitThread(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//unsigned int __stdcall CThinThread::Start(void* pv)
|
|
DWORD WINAPI CThinThread::Start(LPVOID pv)
|
|
{
|
|
CThinThread* pMT = static_cast<CThinThread*> (pv);
|
|
return pMT->Run(WORD_THREAD_WITH_HOGA);
|
|
}
|
|
|
|
DWORD WINAPI CThinThread::Start2(LPVOID pv)
|
|
{
|
|
CThinThread* pMT = static_cast<CThinThread*> (pv);
|
|
return pMT->Run(WORD_THREAD_WITHOUT_HOGA);
|
|
} |