cThread.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cThread_H
#define _INC_cThread_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/cTimeFile.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cLogMgr.h"
#include "GrayCore/include/cAppState.h"
#include "GrayCore/include/cRefPtr.h"
 
#ifdef _MFC_VER
#include <atlutil.h>
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cThread);
 
#ifdef _WIN32
        typedef HANDLE THREADHANDLE_t;  // cOSHandle in WIN32 but not in __linux__
        static const THREADHANDLE_t THREADHANDLE_NULL = HANDLE_NULL;
#elif defined(__linux__)
        typedef THREADID_t THREADHANDLE_t;      // same as THREADID_t pthread_t
        static const THREADHANDLE_t THREADHANDLE_NULL = cThreadId::k_NULL;
#else
#error NOOS
#endif
 
#ifdef _MFC_VER
        typedef CWorkerThread<> cThreadBase; // GetThreadId
#else
        class GRAYLIB_LINK cThreadBase : public CObject, public cThreadId       // GetThreadId
        {
 
        protected:
                THREADHANDLE_t m_hThread;               
 
        public:
                cThreadBase() noexcept
                        : m_hThread(THREADHANDLE_NULL)
                {
                }
                virtual ~cThreadBase()
                {
                }
        };
#endif  // _MFC_VER
 
        class cThread;
        typedef cRefPtr<cThread> cThreadPtr;
 
        class GRAYLIB_LINK cThread : public cThreadBase, public cRefBase, public cThreadState
        {
 
                friend class cThreadMgr;
 
        protected:
                bool m_bThreadSleeping;         
                bool m_bThreadSuspended;        
 
#ifdef __linux__
                THREAD_EXITCODE_t m_nExitCode;  
#endif
 
        protected:
                virtual bool ThreadTick()
                {
 
                        ASSERT(isCurrentThread());      // only call from self thread.
                        return !isThreadStopping();
                }
 
                virtual THREAD_EXITCODE_t Run(); 
 
                THREAD_EXITCODE_t RunDirectly();
 
                static THREAD_EXITCODE_t _stdcall EntryProc(void* pThisThread);
 
                virtual void onThreadCreate();  
                virtual void onThreadExit(THREAD_EXITCODE_t nExitCode); 
                void onThreadTerminated(THREAD_EXITCODE_t nExitCode);
 
        public:
                cThread();
                virtual ~cThread();
 
                static cThread* GRAYCALL GetCurrentThread();
                static bool GRAYCALL IsCurrentThreadStopping();
 
                bool isValidThreadHandle() const noexcept
                {
                        return this->m_hThread != THREADHANDLE_NULL;
                }
 
                THREADID_t get_HashCode() const noexcept
                {
                        return this->m_dwThreadId;
                }
#ifdef _MFC_VER
                bool isCurrentThread() const
                {
                        return cThreadId::IsEqualId(this->get_HashCode(), cThreadId::GetCurrentId());
                }
#endif
 
                virtual bool isValidCheck() const noexcept;     
 
#if defined(_WIN32) && defined(_MSC_VER) && ! defined(UNDER_CE)
                static void GRAYCALL SetThreadName(THREADID_t dwThreadID, const char* pszThreadName);
                bool put_ThreadName(const char* pszThreadName);
#endif
                STDMETHOD_(cString, get_Name)() const;  
 
                bool isThreadSleeping() const noexcept
                {
                        return m_bThreadSleeping;
                }
                THREAD_EXITCODE_t get_ExitCodeThread() const;
 
                int get_ThreadPriority() const;
                bool put_ThreadPriority(int nPriority);
 
                bool SuspendThread();
                bool ResumeThread();
 
                virtual HRESULT SleepThread(TIMESYSD_t dwWaitMillisec = 1, bool bAlertable = false);
                virtual void WakeThread();
 
                virtual bool RequestStopThread(bool bWillWait = false) noexcept override;
                bool ExitCurrentThread(THREAD_EXITCODE_t nExitCode = THREAD_EXITCODE_OK);
 
                bool WaitForThreadExit(TIMESYSD_t nMilliSec = cTimeSys::k_FREQ);
                THREAD_EXITCODE_t WaitForThreadExitCode(TIMESYSD_t iTimeMSec = cTimeSys::k_FREQ);
 
                bool TerminateThread(THREAD_EXITCODE_t iExitCode = THREAD_EXITCODE_ERR, TIMESYSD_t nMilliSec = 0);
 
                static void GRAYCALL RequestStopThreadArray(bool bWillWait, cThread** ppThreads, size_t nThreads);
                static void GRAYCALL TerminateThreadArray(THREAD_EXITCODE_t nExitCode, TIMESYSD_t iTimeMSec, cThread** ppThreads, size_t nThreads);
 
                void AttachToCurrentThread();
                
                HRESULT CreateThread(THREAD_FUNC_t pEntryProc, void* pArgs, DWORD dwCreationFlags = 0);
 
                virtual HRESULT CreateThread(DWORD dwCreationFlags = 0)
                {
                        return CreateThread(EntryProc, this, dwCreationFlags);
                }
 
                void CloseThread();
 
#ifdef _WIN32
                bool GetStatTimes(FILETIME* pKernelTime, FILETIME* pUserTime) const
                {
                        return ::GetThreadTimes(m_hThread, nullptr, nullptr, pKernelTime, pUserTime) ? true : false;
                }
#endif
 
#if defined(_MT)
                UNITTEST_FRIEND(cThread);
#endif
        };
 
        class GRAYLIB_LINK cThreadChecked : public cThread
        {
                typedef cThread SUPER_t;
 
        public:
                UINT m_nThreadTicksLast;                
                cTimeSys m_tStart;                              
                TIMESYS_t m_timeLastChanged;    
                UINT m_nRecoveryStage;                  
 
        protected:
                UINT m_nThreadTicks;                    
 
        private:
                UINT m_nCriticalWaitCount;              
 
        protected:
                virtual bool ThreadTick() override
                {
                        m_nThreadTicks++;
                        return SUPER_t::ThreadTick();
                }
                virtual void onThreadCreate() override;
 
        public:
                cThreadChecked();
                virtual ~cThreadChecked();
 
                virtual bool CheckStuckThread(TIMESYSD_t iMilliSecTilStuck, bool bTerminateAndRestart); 
 
                UINT get_ThreadTicks() const
                {
                        return m_nThreadTicks;
                }
                bool isCriticalWait() const
                {
                        return m_nCriticalWaitCount ? true : false;
                }
                void ChangeCriticalWait(int iDelta)
                {
                        ASSERT(isCurrentThread());
                        m_nCriticalWaitCount += iDelta;
                }
 
                static cThreadChecked* GRAYCALL GetCurrentThreadChecked();
        };
 
        template <class _TYPE>
        class cThreadNamed : public cThreadChecked
        {
 
                typedef cThreadChecked SUPER_t;
 
        protected:
                static THREAD_EXITCODE_t _stdcall EntryProc(void* pThisThread)
                {
                        return SUPER_t::EntryProc(pThisThread);
                }
        public:
                virtual HRESULT CreateThread(DWORD dwCreationFlags = 0) override // start/restart this thread! default RunDirectly() then Run() body
                {
                        return SUPER_t::CreateThread(EntryProc, this, dwCreationFlags);
                }
        };
}
#endif  // _INC_cThread_H