VC++多线程应用--代码清单五:多线程

 

#ifndef _EXECUTETHREAD_H
#define _EXECUTETHREAD_H

#pragma once

#include ".EventDefine.h"
#include ".Note.h"

class __declspec(dllexport) CEvent;

class __declspec(dllexport) CExecuteThread
...{
public:
    CExecuteThread(void);
    ~CExecuteThread(void);
    
    void StartExecuteThread(void);

    void EndExecuteThread(void);
    
    void SetEventPF(OBJECT);
    
    void BeginRun(CNote*, CNote*, CNote*);

protected:
    
    void Run();
    
    void AfterRun(void);
    
    static UINT ExecuteThreadProc(LPVOID pParam);

private:
    CWinThread*    executethread_p;
    OBJECT      eventpf_p;
    CNote*        tasknode_p;
    CNote*        instancenode_p;
    CNote*        threadnode_p;

    CEvent        threadend_e;
    CEvent        threadrun_e;
};

#endif/* _EXECUTETHREAD_H */

 

#include "StdAfx.h"
#include ".ExecuteThread.h"
#include ".EventPF.h"

CExecuteThread::CExecuteThread(void)
    : executethread_p(NULL)
    , eventpf_p(NULL)
    , tasknode_p(NULL)
    , instancenode_p(NULL)
    , threadnode_p(NULL)
...{
}

CExecuteThread::~CExecuteThread(void)
...{
    EndExecuteThread();
}

void CExecuteThread::StartExecuteThread(void)
...{
    executethread_p = AfxBeginThread(ExecuteThreadProc,this);
    if (NULL == executethread_p)...{
        executethread_p->m_bAutoDelete = true;
    }
}

void CExecuteThread::EndExecuteThread(void)
...{
    DWORD exitcode;
    /**//*↓↓↓ add ↓↓↓*/
    if (NULL == executethread_p)...{
        return;
    }
    threadend_e.SetEvent();

    GetExitCodeThread(executethread_p->m_hThread, &exitcode);
    if(STILL_ACTIVE == exitcode)...{
        WaitForSingleObject(executethread_p->m_hThread, INFINITE);
    }
    /**//*↑↑↑ add ↑↑↑*/
}

void CExecuteThread::SetEventPF(OBJECT evpf_p)
...{
    eventpf_p = evpf_p;
}

void CExecuteThread::BeginRun(CNote* nodetask_p, CNote* nodeobject_p, CNote* nodethread_p)
...{
    if (NULL != nodetask_p && NULL != nodeobject_p && NULL != nodethread_p)...{
        this->tasknode_p = nodetask_p;
        this->threadnode_p = nodethread_p;
        this->instancenode_p = nodeobject_p;
    }
    /**//*Start the Event*/
    this->threadrun_e.SetEvent();
}

void CExecuteThread::Run(void)
...{
    CMyEvent* myEvent_p;
    CTask*    task_p;
    CListener* listener_p;

    task_p = (CTask*)tasknode_p->element_p->Get();
    listener_p = task_p->GetListener();
    myEvent_p = task_p->GetEvent();
    listener_p->Action(NULL, myEvent_p->parameter_p);
}

void CExecuteThread::AfterRun(void)
...{
    if (NULL != eventpf_p)...{
        ((CEventPF*)eventpf_p)->AfterRunEvent(tasknode_p, instancenode_p, threadnode_p);
    }
    tasknode_p = NULL;
    threadnode_p = NULL;
    instancenode_p = NULL;
    /**//*Start the Event*/
    /**/////this->threadend_e.SetEvent();
}

UINT CExecuteThread::ExecuteThreadProc(LPVOID pParam)
...{
    CExecuteThread* class_p;
    HANDLE    handles[2];
    DWORD    wretevent;

    class_p = (CExecuteThread*)pParam;
    handles[0] = class_p->threadrun_e.m_hObject;
    handles[1] = class_p->threadend_e.m_hObject;
    
    while (1)...{
        wretevent = WaitForMultipleObjects(2,handles,FALSE,100);
        if (wretevent == WAIT_OBJECT_0)...{
            /**//* no event */
            break;
        }
        else if (wretevent == (WAIT_OBJECT_0 + 1))...{
            /**//*do event*/
            class_p->Run();
            class_p->AfterRun();        
        }
    }
    return 0;
}

POOL

#ifndef _THREADPOOL_H
#define _THREADPOOL_H

#pragma once

#include ".CircularLinkList.h"
#include ".ExecuteThread.h"
#include ".ThreadElement.h"

class __declspec(dllexport) CThreadPool
...{
public:
    CThreadPool(void);
    ~CThreadPool(void);

    void Initial(US, OBJECT);
    
    bool GetIdleThread(CTokenElement**);
    
    bool GetIdleThread(CNote**);
    
    void IdleThreadMoveToBusyPool(CNote*);
    
    void BusyThreadMoveToIdlePool(CNote*);
    
    void Free(void);

protected:
    
    void CreateIdleThread(US);

private:
    US                    threadnum;
    CCircularLinkList    idlelist;
    CCircularLinkList    busylist;
    OBJECT              eventpf_p;
    CCriticalSection    threadpool_cs;
};


#endif/* _THREADPOOL_H */

 

 

#include "StdAfx.h"
#include ".ThreadPool.h"

CThreadPool::CThreadPool(void)
    : threadnum(0)
    , eventpf_p(NULL)
...{
}

CThreadPool::~CThreadPool(void)
...{
    Free();
}

void CThreadPool::Initial(US totalthread, OBJECT evpf_p)
...{
    US i;
    
    eventpf_p = evpf_p;
    threadnum = totalthread;
    for (i = 0; i < totalthread; i++)...{
        CreateIdleThread(totalthread);
    }
}

bool CThreadPool::GetIdleThread(CTokenElement** element_dp)
...{
    CNote*    note_p;
    bool result = false;

    threadpool_cs.Lock();
    if (idlelist.GetHeader(&note_p))...{
        *element_dp = note_p->element_p;
        result = true;
    }
    threadpool_cs.Unlock();
    return result;
}

bool CThreadPool::GetIdleThread(CNote** node_dp)
...{
    threadpool_cs.Lock();
    return idlelist.GetHeader(node_dp);
    threadpool_cs.Unlock();
}

void CThreadPool::IdleThreadMoveToBusyPool(CNote* idlenode_p)
...{
    threadpool_cs.Lock();
    idlelist.PullOut(idlenode_p);
    busylist.PushIn(idlenode_p);
    threadpool_cs.Unlock();
}

void CThreadPool::BusyThreadMoveToIdlePool(CNote* busynode_p)
...{
    threadpool_cs.Lock();
    busylist.PullOut(busynode_p);
    idlelist.PushIn(busynode_p);
    threadpool_cs.Unlock();
}

void CThreadPool::Free(void)
...{
    CNote*    note_p;
    threadpool_cs.Lock();
    while (busylist.GetTail(&note_p))...{
        busylist.Remove(note_p);
    }
    while (idlelist.GetTail(&note_p))...{
        idlelist.Remove(note_p);
    }
    busylist.Free();
    idlelist.Free();
    threadpool_cs.Unlock();
}

void CThreadPool::CreateIdleThread(US totalthread)
...{
    CThreadElement*        threadElement_p;
    CExecuteThread*        executeThread_p;

    executeThread_p = new CExecuteThread();
    threadElement_p = new CThreadElement();

    executeThread_p->SetEventPF(eventpf_p);
    executeThread_p->StartExecuteThread();
    threadElement_p->Set(executeThread_p);
    idlelist.AppendTail((CTokenElement*)threadElement_p);
}