VC++多线程应用--代码清单三:事件TASK

 

#ifndef _TASK_H
#define _TASK_H

#pragma once

#include ".MyEvent.h"
#include ".Listener.h"

class __declspec(dllexport) CTask
...{
public:
    CTask();
    ~CTask();

    void SetListener(CListener*);

    CListener* GetListener(void);

    void SetEvent(CMyEvent*);
    
    CMyEvent* GetEvent(void);

protected:
    CListener*    listener_p;        
    CMyEvent    m_Event;        
};

#endif

 

 

#include "stdafx.h"
#include ".Task.h"

CTask::CTask()
...{
}

CTask::~CTask()
...{
}

void CTask::SetListener(CListener* object_p)
...{
    this->listener_p = object_p;
}

CListener* CTask::GetListener()
...{
    return listener_p;
}

void CTask::SetEvent(CMyEvent* event_p)
...{
    m_Event.m_InitialTick = event_p->m_InitialTick;
    m_Event.m_NowTick = event_p->m_NowTick;
    m_Event.m_Priority = event_p->m_Priority;
    m_Event.m_Trigger = event_p->m_Trigger;
    event_p->parameter_p->Copy(&(m_Event.parameter_p));
}

CMyEvent* CTask::GetEvent()
...{
    return &m_Event;
}

TASKPOOL

 

#ifndef _TASKPOOL_H
#define _TASKPOOL_H

#pragma once
#include ".CircularLinkList.h"
#include ".TaskElement.h"

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

    void Initial(void);
    
    void RaiseTask(CMyEvent*, CListener*);

    void Prepare(void);
    
    bool GetReadyEvent(CTokenElement**);
    
    bool GetReadyEvent(CNote**);

    
    void ReadyTaskMoveToFinishList(CNote*);
    
    void ReadyTaskMoveToRunningList(CNote*);
    
    void RunningTaskMoveToFinishList(CNote*);
    
    void ReadyTaskMoveToBlockList(CNote*);
    
    void BlockTaskMoveToReadyList(CNote*);

    void Free(void);

private:
    CCircularLinkList    m_ReadyList;
    CCircularLinkList    m_RunningList;
    CCircularLinkList    m_FinishList;
    CCircularLinkList    m_BlockList;
    CCriticalSection    m_CriticalSection;
};


#endif/* _EVENTCELL_H */

#include "StdAfx.h"
#include ".TaskPool.h"

CTaskPool::CTaskPool(void)
...{
}

CTaskPool::~CTaskPool(void)
...{
}

void CTaskPool::Initial(void)
...{
    m_CriticalSection.Lock();
    m_CriticalSection.Unlock();
}

void CTaskPool::RaiseTask(CMyEvent* event_p, CListener* listener_p)
...{
    CTaskElement*    taskElement_p;
    CTask*            task_p;

    m_CriticalSection.Lock();
    task_p = new CTask();
    task_p->SetEvent(event_p);
    task_p->SetListener(listener_p);

    taskElement_p = new CTaskElement();
    taskElement_p->Set(task_p);
    m_ReadyList.AppendTail((CTokenElement*)taskElement_p);
    m_CriticalSection.Unlock();
}

void CTaskPool::Prepare(void)
...{
    CNote*    note_p;

    m_CriticalSection.Lock();
    /**//* ↓↓↓Remove finish task↓↓↓ */
    while(m_FinishList.GetHeader(&note_p))...{
        m_FinishList.Remove(note_p);
    }
    /**//* ↑↑↑Remove finish task↑↑↑  */

    while (m_BlockList.GetHeader(&note_p))...{
        BlockTaskMoveToReadyList(note_p);
    }
    m_CriticalSection.Unlock();
}

bool CTaskPool::GetReadyEvent(CTokenElement** element_dp)
...{
    CNote*    note_p;
    bool result = false;

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


bool CTaskPool::GetReadyEvent(CNote** node_dp)
...{
    m_CriticalSection.Lock();
    return m_ReadyList.GetHeader(node_dp);
    m_CriticalSection.Unlock();
}

void CTaskPool::ReadyTaskMoveToFinishList(CNote* node_p)
...{
    m_CriticalSection.Lock();
    m_ReadyList.PullOut(node_p);
    m_FinishList.PushIn(node_p);
    m_CriticalSection.Unlock();
}

void CTaskPool::ReadyTaskMoveToRunningList(CNote* node_p)
...{
    m_CriticalSection.Lock();
    m_ReadyList.PullOut(node_p);
    m_RunningList.PushIn(node_p);
    m_CriticalSection.Unlock();
}

void CTaskPool::RunningTaskMoveToFinishList(CNote* node_p)
...{
    m_CriticalSection.Lock();
    m_RunningList.PullOut(node_p);
    m_FinishList.PushIn(node_p);
    m_CriticalSection.Unlock();
}

void CTaskPool::ReadyTaskMoveToBlockList(CNote* node_p)
...{
    m_CriticalSection.Lock();
    m_ReadyList.PullOut(node_p);
    m_BlockList.PushIn(node_p);
    m_CriticalSection.Unlock();
}

void CTaskPool::BlockTaskMoveToReadyList(CNote* node_p)
...{
    m_CriticalSection.Lock();
    m_BlockList.PullOut(node_p);
    m_ReadyList.PushIn(node_p);
    m_CriticalSection.Unlock();
}

void CTaskPool::Free(void)
...{
    m_CriticalSection.Lock();
    this->m_FinishList.Free();
    this->m_BlockList.Free();
    this->m_ReadyList.Free();
    this->m_RunningList.Free();
    m_CriticalSection.Unlock();
}