spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Klasse mit Thread-Funktion

class BackgroundProcess: public TThread
{
private:
// Paar kleine Extra Funktionen ( Namen sprechen für sich ;) )

    virtual void    OnEnter()   { std:: cout << "Start !!!\n"; }
    virtual void    OnKill()    { std:: cout << "Getötet Nein....!!!\n";}
    virtual void    OnStop()    { std:: cout << "Kurzer Stop!!!\n";}
    virtual void    OnResume()  { std:: cout << "Weiter Gehts!!!\n";}
 

// Diese Funktion wird jetzt in einem neuen Thread ausgeführt !

    virtual DWORD   Run()
    {
        // Immer wiederholen

        while(true)
        {
            std::cout << "Nerve ich ???";
            sleep(10000);
        }
        return 1;
    }
}


// ----------- Hier die anwendung -----------------

BackgroundProcess BGP;

// Jetzt starten ( ohne Parameter und sofort nach Aufruf )

BGP.create(NULL, true);

// Noch die Priorität runter setzten

BGP.SetPriority(TTP_Lowest);

// Kurz mal stoppen

BGP.Stop();

// wieder starten

BGP.Resum();

// Und beenden ( sollte möglichst vermieden werden.. normalerweise würde man oben die while-schleife auslaufen lassen.)

BGP. Kill();

C-/C++-Quelltext

/*
 *  + TThread_raw <typename T_ThreadParamType_, 
 *                  SIZE_T T_ThreadStackSize_ = 0>
 *  ----------------------------------------------------------------------------
 *  Klasse zur unterstützung von Threads.
 *  Erbende Klassen müssen eine Run-funktion beinhalten,
 *  die aufgerufen wird wenn der Thread gestartet ist.
 *  Außerdem gibt es Funktionen zum stoppen anhalten und
 *  wieder starten.
 *  ----------------------------------------------------------------------------
 *
 *
 *
 */


///////////////////////////////////////////////// e_TThreadPriority_ /////////////////////////////////////////////////


enum e_TThreadPriority_
{
    TTP_Idle                = THREAD_PRIORITY_IDLE,
    TTP_Lowest              = THREAD_PRIORITY_LOWEST,
    TTP_Low                 = THREAD_PRIORITY_BELOW_NORMAL,
    TTP_Normal              = THREAD_PRIORITY_NORMAL,
    TTP_Hight               = THREAD_PRIORITY_ABOVE_NORMAL,
    TTP_Hightest            = THREAD_PRIORITY_HIGHEST,
    TTP_TimeCritical        = THREAD_PRIORITY_TIME_CRITICAL,

    TTP_StartBackgroundMode = THREAD_MODE_BACKGROUND_BEGIN,
    TTP_StopBackgroundMode  = THREAD_MODE_BACKGROUND_END

};



///////////////////////////////////////////////// TThread_raw /////////////////////////////////////////////////


template<typename T_ThreadParamType_, SIZE_T T_ThreadStackSize_ = 0>
class TThread_raw
{
private:
    /* 
        Id des Threads 
    */
    DWORD                   _m_ThreadId_;


    /*
        Handle des Threads
    */
    HANDLE                  _m_ThreadHandle_;
    

    /* 
        Zeiger auf eine Struktur die Informationen für den Thread enthält o.ä.
    */
    T_ThreadParamType_*     _m_ThreadParam_;




    /*
        Interne Funktion zum starten des Threads
    */
    static DWORD WINAPI EntryPoint(void * _pStartingThread)
    {
       TThread_raw* _pStartThread = reinterpret_cast<TThread_raw*>(_pStartingThread);
       return _pStartThread->Run();
    }

protected:
    
    virtual void    OnEnter()       {}
    virtual DWORD   Run()           { return (1); }
    virtual void    OnKill()        {}
    virtual void    OnStop()        {}
    virtual void    OnResume()      {}

public:
    TThread_raw()
        : _m_ThreadId_(0)
    {}  

    /*
        Erstellt den Thread
    */
    DWORD   Create( T_ThreadParamType_* _ThreadParam    = NULL,
                    BOOL                _StartMomently  = true );


    /*
        Hält den Thread an. Er kann mit Resume wieder aktiviert werden
    */
    inline  DWORD   Stop()                                  { OnStop();     return SuspendThread(       _m_ThreadHandle_    ); }


    /*
        Holt den Thread aus dem Ruhezustand
    */
    inline  DWORD   Resume()                                { OnResume();   return ResumeThread(        _m_ThreadHandle_    ); }


    /*
        Elemeniert den Thread komplett
    */
    inline  BOOL    Kill()                                  { OnKill();     return TerminateThread( _m_ThreadHandle_, 1 ); }


    /*
        Setzt die Priorität des Threads
    */
    inline BOOL     SetPriority(e_TThreadPriority_ _pr)     { return SetThreadPriority(_m_ThreadHandle_, _pr); }



    // Inline - Methoden

    inline  DWORD               GetThreadId()       const   { return _m_ThreadId_; }
    inline  HANDLE              GetThreadHandle()   const   { return _m_ThreadHandle_; }
    inline  T_ThreadParamType_* GetThreadParam()    const   { return _m_ThreadParam_; }
};

template<typename T_ThreadParamType_, SIZE_T T_ThreadStackSize_ >
DWORD 
    TThread_raw<T_ThreadParamType_, T_ThreadStackSize_>
        ::Create(   T_ThreadParams_*    _ThreadParam,    // = NULL

                    BOOL                _StartMomently)   // = true

{
    OnEnter();

    _m_ThreadHandle_ = CreateThread(NULL,
                                    T_ThreadStackSize_,
                                    TThread_raw::EntryPoint,
                                    this,
                                    ( (_StartMomently)? (0) : (CREATE_SUSPENDED) ),
                                    &_m_ThreadId_);
    _m_ThreadParam_ = _ThreadParam;
    return (_m_ThreadId_);
}



typedef TThread_raw<void>   TThread;