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

#ifndef _EVENTPOOL_H
#define  _EVENTPOOL_H

#pragma  once

#include  " .CircularLinkList.h "
#include  " .EventElement.h "

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

    
    void Initial(void);
    
    void RaiseEvent(US, US, CEventPara*);
    
    bool GetEvent(CNote**);
    
    void CancelEvent(CNote*);
    
    void Free(void);

protected:
    void RaiseEvent(US, US, CEventPara*, CCircularLinkList*);

private:
    CCircularLinkList    m_LowEventList;
                     CCircularLinkList    m_MiddleEventList;
    CCircularLinkList    m_HighEventList;
    CCriticalSection    m_CriticalSection;
} ;


#endif /* _EVENTPOOL_H */

 

 

#include  " StdAfx.h "
#include  " .EventPool.h "

CEventPool::CEventPool( void )
... {
}

CEventPool:: ~ CEventPool( void )
... {
    /**/////Free();
}

void  CEventPool::Initial( void )
... {
}

void  CEventPool::RaiseEvent(US rank, US trig, CEventPara *  para_p)
... {
    m_CriticalSection.Lock();
    switch (rank)...{
    case TASK_RANK_LOW:
        RaiseEvent(rank,trig,para_p,&m_LowEventList);
        break;
    case TASK_RANK_MIDDLE:
        RaiseEvent(rank,trig,para_p,&m_MiddleEventList);
        break;
    case TASK_RANK_HIGH:
        RaiseEvent(rank,trig,para_p,&m_HighEventList);
        break;
    default:
        break;
    }
    m_CriticalSection.Unlock();
}

bool  CEventPool::GetEvent(CNote **  node_dp)
... {
    bool result = false;

    m_CriticalSection.Lock();
    result = m_HighEventList.GetHeader(node_dp);
    if (!result)...{
        result = m_MiddleEventList.GetHeader(node_dp);
        if (!result)...{
            result = m_LowEventList.GetHeader(node_dp);
        }
    }
    return result;
    m_CriticalSection.Lock();
}


void  CEventPool::CancelEvent(CNote *  node_p)
... {
    m_CriticalSection.Lock();
    m_HighEventList.Remove(node_p);
    m_MiddleEventList.Remove(node_p);
    m_LowEventList.Remove(node_p);
    m_CriticalSection.Lock();
}

void  CEventPool::Free( void )
... {
    m_CriticalSection.Lock();
    m_HighEventList.Free();
    m_MiddleEventList.Free();
    m_LowEventList.Free();
    m_CriticalSection.Lock();
}


void  CEventPool::RaiseEvent(US rank, US trig, CEventPara *  para_p, CCircularLinkList *  list_p)
... {
    CEventElement* eventElement_p;
    CMyEvent*    myEvent_p;

    myEvent_p = new CMyEvent();
    eventElement_p = new CEventElement();
    myEvent_p->m_Trigger = trig;
    myEvent_p->m_Priority = rank;
    myEvent_p->parameter_p->Copy(&para_p);
    eventElement_p->Set(myEvent_p);
    list_p->AppendTail(eventElement_p);
}

 

 

#ifndef _LISTENERPOOL_H
#define  _LISTENERPOOL_H

#pragma  once

#include  " .CircularLinkList.h "
#include  " .HashTable.h "
#include  " .ListElement.h "
#include  " .ListenerElement.h "

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

    void Initial(void);

    void RaiseListener(CListener*);
    
    void CancelListener(US);
    void CancelListener(CListener*);
    
    bool FetchTrigListener(US, CListElement**);
    
    bool FetchTrigListener(US, CNote**);

    void RaiseRunningInstance(OBJECT, CNote**);
    
    void CancelRunningInstance(OBJECT);
    
    void CancelRunningInstance(CNote*);
    
    bool IsRunningInstance(OBJECT);
    
    void Free(void);

private:
    CHashTable            m_ListenerListTable;
    CCircularLinkList    m_InstanceList;
    CCriticalSection    m_CriticalSection;
} ;


#endif /* _LISTENERPOOL_H */

 

 

#include  " StdAfx.h "
#include  " .ListenerPool.h "

CListenerPool::CListenerPool( void )
... {
}

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

void  CListenerPool::Initial( void )
... {
}

void  CListenerPool::RaiseListener(CListener *  listener_p)
... {
    US trig;
    CListenerElement* listenerElement_p;
    CListElement*        listElement_p;
    CCircularLinkList*    circularLinkList_p;
    CNote*    note_p;

    m_CriticalSection.Lock();
    if (NULL != listener_p)...{
        listenerElement_p = new CListenerElement();
        trig = listener_p->GetTrig();

        listenerElement_p->Set(listener_p);
        if (m_ListenerListTable.Search(trig,&note_p))...{
            /**//*finded listener list*/
            listElement_p = (CListElement*)note_p->element_p->Get();
            circularLinkList_p = listElement_p->Get();
            circularLinkList_p->AppendTail((CTokenElement*)listenerElement_p);
        }
        else...{
            /**//*not find*/
            circularLinkList_p = new CCircularLinkList();
            listElement_p = new CListElement();
            circularLinkList_p->AppendTail((CTokenElement*)listenerElement_p);
            listElement_p->Set(circularLinkList_p);
            this->m_ListenerListTable.Raise(trig,(CTokenElement*)listElement_p);
        }
    }
    m_CriticalSection.Unlock();
}

void  CListenerPool::CancelListener(US trig)
... {
    m_CriticalSection.Lock();
    m_ListenerListTable.Remove(trig);
    m_CriticalSection.Unlock();
}

void  CListenerPool::CancelListener(CListener *  listener_p)
... {
    US trig;
    CCircularLinkList* listenerlist_p;
    CNote*  note_p;

    m_CriticalSection.Lock();
    if (NULL != listener_p)...{
        /**//*↓↓↓↓↓↓↓↓↓*/
        trig = listener_p->GetTrig();
        /**//*↑↑↑↑↑↑↑↑↑*/
        if (m_ListenerListTable.Search(trig,&note_p))...{
            /**//*Get listener list*/
            listenerlist_p = (CCircularLinkList*)(note_p->element_p->Get());
            /**//*delete listener In Link List*/
            listenerlist_p->Remove((OBJECT)listener_p);
        }
    }
    m_CriticalSection.Unlock();
}

bool  CListenerPool::FetchTrigListener(US trig, CListElement **  listener_dp)
... {
    bool result = false;

    m_CriticalSection.Lock();
    if (m_ListenerListTable.Search(trig,(CTokenElement**)listener_dp))...{
        result = true;
    }
    m_CriticalSection.Unlock();

    return result;
}

bool  CListenerPool::FetchTrigListener(US trig, CNote **  node_dp)
... {
    bool result = false;

    m_CriticalSection.Lock();
    if (m_ListenerListTable.Search(trig,node_dp))...{
        result = true;
    }
    m_CriticalSection.Unlock();
    return result;
}

void  CListenerPool::RaiseRunningInstance(OBJECT instance_p, CNote **  node_dp)
... {
    CTokenElement*    tokenElement_p;

    m_CriticalSection.Lock();
    tokenElement_p = new CTokenElement();
    tokenElement_p->Set(instance_p);
    m_InstanceList.AppendTail(tokenElement_p);
    m_InstanceList.GetTail(node_dp);
    m_CriticalSection.Unlock();
}

void  CListenerPool::CancelRunningInstance(OBJECT instance_p)
... {
    m_CriticalSection.Lock();
    m_InstanceList.Remove(instance_p);
    m_CriticalSection.Unlock();
}

void  CListenerPool::CancelRunningInstance(CNote *  node_p)
... {
    m_CriticalSection.Lock();
    m_InstanceList.Remove(node_p);
    m_CriticalSection.Unlock();
}

bool  CListenerPool::IsRunningInstance(OBJECT instance_p)
... {
    CNote*    note_p;
    bool    result = false;

    m_CriticalSection.Lock();
    if (m_InstanceList.GetHeader(&note_p))...{
        while (    NULL != note_p)...{
            /**//*Check Instance*/
            if (instance_p == note_p->element_p->Get())...{
                result = true;
                break;
            }
            /**//*Next Node*/
            m_InstanceList.GetNext(note_p);
        }
    }
    m_CriticalSection.Unlock();
    return result;
}

void  CListenerPool::Free( void )
... {
    CNote*    node_p;
    m_CriticalSection.Lock();
    while (NULL != m_ListenerListTable.SearchAllNode(&node_p))...{
        /**/////delete node_p->element_p;
        ////delete node_p;
        m_ListenerListTable.Remove(node_p->key);
    }
    m_ListenerListTable.Free();
    m_InstanceList.Free();
    m_CriticalSection.Unlock();
}

哈希表

 

#ifndef _HASHTABLE_H
#define  _HASHTABLE_H

#pragma  once

#include  " .OrdinalLinkList.h "

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

    void Raise(US, CTokenElement*);

    void Remove(US);

    bool Search(US, CNote**);
    bool Search(US, CTokenElement**);

    bool SearchAllNode(CNote**);

    void Free(void);

protected:
    US HashFunc(US);

private:
    COrdinalLinkList hashtable_t[HASHSIZE];
} ;


#endif /* _HASHTABLE_H */

 

 

#include  " StdAfx.h "
#include  " .HashTable.h "

CHashTable::CHashTable( void )
... {
}

CHashTable:: ~ CHashTable( void )
... {
/**/////    Free();
}

void  CHashTable::Raise(US key, CTokenElement *  element_p)
... {
    hashtable_t[HashFunc(key)].Insert(key,element_p);
}

void  CHashTable::Remove(US key)
... {
    hashtable_t[HashFunc(key)].Remove(key);
}

bool  CHashTable::Search(US key, CNote **  node_dp)
... {
    bool result = false;
    CNote* note_p;

    if(hashtable_t[HashFunc(key)].Search(key,&note_p))...{
        *node_dp = note_p;
        result = true;
    }
    return result;
}

bool  CHashTable::Search(US key, CTokenElement **  element_dp)
... {
    bool result = false;
    CNote* note_p;

    if(hashtable_t[HashFunc(key)].Search(key,&note_p))...{
        *element_dp = note_p->element_p;
        result = true;
    }
    return result;
}

bool  CHashTable::SearchAllNode(CNote **  node_dp)
... {
    int i;
    bool result = false;

    for (i = 0; i < HASHSIZE; i++)...{
        result = hashtable_t[i].GetHeader(node_dp);
        if (result)...{
            break;/**//*find the node break this method*/
        }
    }
    return result;
}

void  CHashTable::Free( void )
... {
    int i;

    for (i = 0; i<HASHSIZE; i++)...{
        hashtable_t[i].Free();
    }
}

US CHashTable::HashFunc(US key)
... {
    return (key % HASHSIZE);
}