VC++多线程应用--代码清单六:定时

#ifndef __TIMERCYCLE_H
#define  __TIMERCYCLE_H

#pragma  once

#include  " .EventDefine.h "

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

    void Initial(OBJECT);
    
    void StartTimerCycle(void);
    
    void StopTimerCycle(void);

protected:
    
    static void CALLBACK OnTimeProc(UINT, UINT, DWORD, DWORD, DWORD);
    
    void SetTimerCyclicHandler(void);

private:
    UINT    m_TimerID;
    UINT    m_TimerRes;
    static OBJECT  eventpf_p;

} ;

#endif

 

 

#include  " StdAfx.h "
#include  < mmsystem.h >
#include  " .TimerCycle.h "
#include  " .EventPF.h "

OBJECT CTimerCycle::eventpf_p  =  NULL;

CTimerCycle::CTimerCycle( void )
    : m_TimerID(NULL)
    , m_TimerRes(NULL)
... {
}

CTimerCycle:: ~ CTimerCycle( void )
... {
    StopTimerCycle();
    m_TimerID = 0;
    m_TimerRes = 0;
}

void  CTimerCycle::Initial(OBJECT evpf_p)
... {
    eventpf_p = evpf_p;
    StartTimerCycle();
}

void  CTimerCycle::StartTimerCycle( void )
... {
    TIMECAPS tc;

    if(timeGetDevCaps(&tc,sizeof(TIMECAPS))==TIMERR_NOERROR)...{
        m_TimerID = min(max(tc.wPeriodMin,m_TimerID),tc.wPeriodMax); 
        timeBeginPeriod(m_TimerID);
        SetTimerCyclicHandler();
    }
    
}

void  CTimerCycle::StopTimerCycle( void )
... {
    timeKillEvent(m_TimerRes);
    timeEndPeriod(m_TimerID);
}

void  CALLBACK CTimerCycle::OnTimeProc(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
... {
    if (NULL != eventpf_p)...{
        ((CEventPF*)eventpf_p)->Clock();
    }
}

void  CTimerCycle::SetTimerCyclicHandler( void )
... {
    m_TimerRes = timeSetEvent(TICKBASETIME, m_TimerID, (LPTIMECALLBACK)OnTimeProc, (DWORD)0,TIME_PERIODIC);
}

 

 

 

#ifndef _TIMEUPEVENTPOOL_H
#define  _TIMEUPEVENTPOOL_H

#pragma  once

#include  " .EventPool.h "

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

    
    void Initial(CEventPool*);
    
    US GetUniqueId(US);
    
    void RaiseEvent(UL, US, US, CEventPara*);
    
    void ClockTimeUpEventList(void);
    
    void Free(void);

private:
    static US            m_UniqueId;
    CEventPool*            eventpool_p;
    CCircularLinkList    m_TimeUpEventList;
    CCriticalSection    m_CriticalSection;
} ;


#endif /* _TIMEUPEVENTPOOL_H */

 

#include  " StdAfx.h "
#include  " .TimeUpEventPool.h "


#define         Msec_to_Ticks(n)    (UL)(n < TICKBASETIME ? 1 : (n / TICKBASETIME + 1))

US CTimeUpEventPool::m_UniqueId  =   0 ;

CTimeUpEventPool::CTimeUpEventPool( void )
    : eventpool_p(NULL)
... {
}

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

void  CTimeUpEventPool::Initial(CEventPool *  obj)
... {
    m_CriticalSection.Lock();
    eventpool_p = obj;
    m_UniqueId = 0;
    m_CriticalSection.Unlock();
}

US CTimeUpEventPool::GetUniqueId(US size)
... {
    US result;

    m_CriticalSection.Lock();

    result = ( ++m_UniqueId % (US_MAX - size) ) + size;

    m_CriticalSection.Unlock();

    return result;
}

void  CTimeUpEventPool::RaiseEvent(UL time, US size, US trig, CEventPara *  para_p)
... {
    CMyEvent*            myEvent_p;
    CEventElement*        element_p;

    m_CriticalSection.Lock();
    myEvent_p = new CMyEvent();
    element_p = new CEventElement();
    myEvent_p->m_InitialTick = Msec_to_Ticks(time);
    myEvent_p->m_NowTick = Msec_to_Ticks(time);
    myEvent_p->m_TrigMax = size; 
    myEvent_p->m_Trigger = trig;
    myEvent_p->parameter_p = para_p;
    element_p->Set(myEvent_p);
    m_TimeUpEventList.AppendTail(element_p);

    m_CriticalSection.Unlock();
}

void  CTimeUpEventPool::ClockTimeUpEventList( void )
... {
    CNote*    rootnode_p;
    CNote*    node_p;
    CMyEvent*        myEvent_p;
    CEventPara*        eventPara_p;
    m_CriticalSection.Lock();

    if (m_TimeUpEventList.GetHeader(&rootnode_p))...{
        while( NULL != rootnode_p ) ...{
            myEvent_p = (CMyEvent*)rootnode_p->element_p->Get();
            
            myEvent_p->m_NowTick--;
            if (0 >= myEvent_p->m_NowTick)...{
                /**//*Copy the Parm*/
                myEvent_p->parameter_p->Copy(&eventPara_p);
                /**//*On The Time, Raise Event*/
                this->eventpool_p->RaiseEvent(TASK_RANK_HIGH,myEvent_p->m_Trigger,eventPara_p);

                node_p = rootnode_p;
                /**//*next node*/
                rootnode_p = m_TimeUpEventList.GetNext(rootnode_p);
                /**//*delete the node*/
                m_TimeUpEventList.Remove(node_p);
            }
            else...{
                rootnode_p = m_TimeUpEventList.GetNext(rootnode_p);
            }

        }
    }
    m_CriticalSection.Unlock();
}

void  CTimeUpEventPool::Free( void )
... {
    m_CriticalSection.Lock();
    m_TimeUpEventList.Free();
    m_UniqueId = 0;
    m_CriticalSection.Unlock();
}