1. Konstantin Bukin CSE791 – Advanced Windows Programming Summer 2001
More on threads
Konstantin Bukin
CSE791 – Advanced Windows Programming
Summer 2001

2. MFC’s thread implementation MFC Internals by G. Shepherd, S. Wingo
Executing a class member in its own thread (C/C++ Users Journal, Vol.17, No. 12, p. 57)
Singleton Creation the thread-safe way (C/C++ Users Journal, Vol.17, No. 10, p. 43)
Improving performance with thread-private heaps (C/C++ Users Journal, Vol.17, No. 9, p. 50)

3. Thread’s thread creation
CWinThread* AFXAPI AfxBeginThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam,
int nPriority, UINT nStackSize,
DWORD dwCreateFlags, LPSECURITY_ATTRIBUTES lpSecurityAttrs);
CWinThread* AFXAPI AfxBeginThread(CRuntimeClass* pThreadClass,

4. AfxBeginThread() It’s all about CWinThread and it’s CreateThread()
CWinThread* pThread = new CWinThread(pfnThreadProc, pParam);
if (!pThread->CreateThread( dwCreateFlags | CREATE_SUSPENDED, nStackSize, lpSecurityAttrs)) {
pThread->Delete();
return NULL; }
VERIFY(pThread->SetThreadPriority(nPriority));
if (!(dwCreateFlags & CREATE_SUSPENDED))
VERIFY(pThread->ResumeThread() != (DWORD)-1);
return pThread;
It’s all about CWinThread and it’s CreateThread()

5. CWinThread class CWinThread : public CCmdTarget { public:
CWinThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam);
BOOL CreateThread(DWORD dwCreateFlags = 0, UINT nStackSize = 0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);
virtual BOOL InitInstance();
virtual int Run();
virtual BOOL PreTranslateMessage(MSG* pMsg);
virtual BOOL PumpMessage(); // low level message pump
virtual BOOL OnIdle(LONG lCount); //return TRUE if more idle processing
virtual BOOL IsIdleMessage(MSG* pMsg); //checks for special messages
private:
LPVOID m_pThreadParams; //generic parameters passed to starting function
AFX_THREADPROC m_pfnThreadProc;
HANDLE m_hThread; // this thread's HANDLE
} Back to AfxBeginThread()

6. CWinThread::CreateThread()
Initialization of _AFX_THREAD_STARTUP startup structure
m_hThread = (HANDLE)_beginthreadex(lpSecurityAttrs,
nStackSize, &_AfxThreadEntry, &startup, dwCreateFlags|
CREATE_SUSPENDED, (UINT*) &m_nThreadID);
ResumeThread(), ::ResumeThread(m_hThread)
::WaitForSingleObject(startup.hEvent, INFINITE)
_AfxThreadEntry()
Cleans up after creating child thread
::SetEvent(startup.hEvent2)
_AfxThreadEntry() keeps running
Pic

7. _AfxThreadEntry()
Copies and initializes thread’s specific data (a lot of them)
Unblocks parent thread
::WaitForSingleObject(startup.hEvent2, INFINITE)
Back to CWinThread::CreateThread()
if (pThread->m_pfnThreadProc != NULL)
nResult=(*pThread->m_pfnThreadProc)(pThread->m_pThreadParams);
else if (!pThread->InitInstance())
nResult=pThread->ExitInstance();
else
pThread-> Run();
//clean up and shutdown thread
AfxEndThread(nResult);
Pic

8. A time line for Mom and Junior threads

9. CWinThread::Run() int CWinThread::Run() { ASSERT_VALID(this);
// for tracking the idle time state
BOOL bIdle = TRUE;
LONG lIdleCount = 0;
// acquire and dispatch messages until a WM_QUIT message is received.
for (;;)
{ // phase1: check to see if we can do idle work
while (bIdle && !::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE))
{ // call OnIdle while in bIdle state
if (!OnIdle(lIdleCount++))
bIdle = FALSE; // assume "no idle" state
} // phase2: pump messages while available
do { // pump message, but quit on WM_QUIT
if (!PumpMessage())
return ExitInstance();
// reset "no idle" state after pumping "normal" message
if (IsIdleMessage(&m_msgCur)) {
bIdle = TRUE;
lIdleCount = 0;}
} while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE)); }
ASSERT(FALSE); // not reachable

10. CWinThread::OnIdle()
BOOL CWinThread::OnIdle(LONG lCount){
if (lCount <= 0) {
// send WM_IDLEUPDATECMDUI to the main window
// send WM_IDLEUPDATECMDUI to all frame window
else if (lCount >= 0) {
//Call AfxLockTempMaps/AfxUnlockTempMaps
//to free maps, DLLs, etc }
return lCount < 0; //nothing more to do if lCount >= 0

11. Executing a class member in its own thread
Motivation
class Task {…};
class Processor {
public:
void SubmitTask(Task t);
private:
usigned ProcessTask(void *data);
std::queue<Task> m_tasks; }
Problem
WINBASEAPI HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, WDORD dwCreationFlags, LPDWORD lpThreadID);

12. Usage
Foo f;
runInThread(f, &Foo::member, args);

13. Solution #1 template <class Object>
void runInThread(Object& obj, DWORD(WINAPI Objecg::*memberFunc)(void), HANDLE* handle=0, DWORD* id=0) {
using std::runtime_error;
DWORD (WINAPI *threadFunc)(void*);
//pass object “this” pointer via thread void* pointer
void *thisPointer=satic_cast<void*>(&obj);
//copy class member pointer to global function pointer
*reinterpret_cast<long*>(&threadFunc)=*reinterpret_cast<long*>(&memberFunc);
DWORD threadId = -1;
HANDLE result=CreateThread(0, 0, threadFunc, thisPointer, 0, &threadId);
if (result == 0) throw runtime_error(“CreateThread failed”);
if (handle) *handle=result;
if (id) *id = threadId; }

14. Problems of solution #1
The solution relies on WINAPI calling convention (__stdcall) which is not always possible. It would not work with const member functions.
The solution assumes (incorectly) that non-static member function will always revieve their this pointer as the first argument on the call stack.
Using the void* thread argument to pass the object this pointer prevents the member function from taking any parameters. It’s a big limitation.

15. Solution #2
template <class Object, class MemberFunc, class Param>
class ThreadableMember {
private:
Object& m_instance;
MemberFunc m_member;
struct ThrdArg {
Object *object;
MemberFunc memberFunc;
Param param;
ThrdArg(Object& o, MemberFunc m, const Param& p) :
object(o), memberFunc(m), param(p) {} };
static DWORD WINAPI ThreadFunc(LPVOID v) {
std::auto_ptr<ThrdArg> arg(reinterpret_cast<ThrdArg*>(v);
return ((arg->object)->*(arg->memberFunc))(arg->param); }

16. Solution #2 (cont.) public:
ThreadableMember(Object& instance, MemberFunc member) : m_instance(instance), m_member(member) {}
void run(const Param& param, HANDLE* handle=0, DWORD* id=0){
DWORD thrdId=-1;
ThrArg* thrdArg = new ThrArg(m_instance, m_member, param);
HANDLE result = CreateThread(0, 0, &ThreadFunc, thrdArg,0,&thrdId);
if (result != 0){
if (handle) *handle=result;
if (id) *id = thrdId;
} else {
delete thrdArg;
throw std::tuntime_error(“CreateThread failed”); } };

17. Usage Foo f; ThreadableMember<Foo, DWORD(Foo::*)(char*), char*>
m(f, &Foo::Bar1);
m.run(“alpha”);
Helper function:
template <class Object, class MemberFunc, class Param>
inline void runInThread(Object& instance, MemberFunc member,
const Param& param, HANDLE* handle=0, DWORD* id=0){
ThreadableMember<Object,MemberFunc,Param> m(instance, member);
m.run(param, handle, id); }
runInThread(f, &Foo::Bar2, class Bar2Param);

18. Issues Take care of you data members
Thread security and stack-size can be added as a parameters to Threadable::run() and runInThread()
One more parameter (perhaps, with default value) can be added to create thread in a suspended state

19. Singleton Creation in a Thread-safe Way
class Singleton {
public:
static Singleton& instance(){
if (!m_instance)
m_instance = new Singleton;
return *m_instance; }
protected:
Singleton();
private:
static Singleton* m_instance; };
Singleton* Singleton::m_instance = 0;

20. Problem
Thread may be preempted by the operating system during if (!m_instance). Then another thread gets control. Since the first thread did not finished creation of the m_instance, the second thread evaluates (!m_instance) as true and creates another singleton.

21. Solution class Singleton { public: static Singleton& instance(){
m_key.Lock();
if (!m_instance)
m_instance = new Singleton;
return *m_instance;
m_key.Unlock(); }
protected:
Singleton();
private:
static Singleton* m_instance;
static CCriticalSection m_key; };
Singleton* Singleton::m_instance = 0;
CCriticalSection Singleton::m_key;
Different from the code in the article

22. Heaps Let’s compare these two functions: void SomeFunc(Foo bar){
Obj* pObj=new Obj;
pObj->Hadler(bar);
delete pObj; }
Obj obj;
obj.Hadler(bar);

23. Possible memory leak (can be solved with auto_ptr)
Heap is a shared resource, which has to be synchronized
The more interdependences between threads the less scalable application

24. Process heap and Private heap
When a new Win32 process starts up, OS creates a default Process heap. GetProcessHeap() returns its handle
HANDLE HeapCreate(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize) creates Private heap
LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, DWORD dwButes);
BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
BOOL HeapDestroy(HANDLE hHeap);
Serialization is turned on by default, but can be turned off by using a flag value of HEAP_NO_SERIALIZE
Access to the process heap in an multithreaded application must be serialized.