TnbThread.h

[詳解]

#pragma once
#include "TnbExchanger.h"
#include "TnbStrLib.h"
#ifndef _WIN32_WCE
 #include <process.h>
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#if ! defined(_WIN32_WCE)
  #if defined(__AFX_H__)
    // MFC
    inline HANDLE il_CreateThread(LPVOID pAddr, LPVOID pParam, DWORD* pThreadId)
    {
        CWinThread* P = ::AfxBeginThread(static_cast<AFX_THREADPROC>(pAddr), pParam, 0, 0, CREATE_SUSPENDED, NULL);
        if ( P != NULL )
        {
            *pThreadId = P->m_nThreadID;
            return P->m_hThread;
        }
        return NULL;
    }
    inline void il_ExitThread(DWORD dwResult)
    {
        ::AfxEndThread(dwResult);
    }
    inline void il_CloseThreadHandle(HANDLE h)
    {
    }
  #elif defined(_MT)
    // Cランタイム使用バージョン
    inline HANDLE il_CreateThread(LPVOID pAddr, LPVOID pParam, DWORD* pThreadId)
    {
        UINT uId = 0;
        typedef unsigned(__stdcall* P_FUNC)(LPVOID);
        INT_PTR dw = ::_beginthreadex(NULL, 0 , static_cast<P_FUNC>(pAddr), pParam, CREATE_SUSPENDED, &uId);
        *pThreadId = uId;
        return reinterpret_cast<HANDLE>(dw);
    }
    inline void il_ExitThread(DWORD dwResult)
    {
        ::_endthreadex(dwResult);
    }
    inline void il_CloseThreadHandle(HANDLE h)
    {
        ::CloseHandle(h);
    }
  #else
    // API 使用バージョン
    inline HANDLE il_CreateThread(LPVOID pAddr, LPVOID pParam, DWORD* pThreadId)
    {
        return ::CreateThread(NULL, 0, static_cast<LPTHREAD_START_ROUTINE>(pAddr), pParam, CREATE_SUSPENDED, pThreadId);
    }
    inline void il_ExitThread(DWORD dwResult)
    {
        ::ExitThread(dwResult);
    }
    inline void il_CloseThreadHandle(HANDLE h)
    {
        ::CloseHandle(h);
    }
  #endif
#else
    // API 使用バージョン
    inline HANDLE il_CreateThread(LPVOID pAddr, LPVOID pParam, DWORD* pThreadId)
    {
        return ::CreateThread(NULL, 0, static_cast<LPTHREAD_START_ROUTINE>(pAddr), pParam, CREATE_SUSPENDED, pThreadId);
    }
    inline void il_ExitThread(DWORD dwResult)
    {
        ::ExitThread(dwResult);
    }
    inline void il_CloseThreadHandle(HANDLE h)
    {
        ::CloseHandle(h);
    }
#endif
 
#ifdef _DEBUG
  // デバグ表示用
  #ifdef __MSVCPP6__
    #define TNB_THREADNAMEFRM1  "ｽﾚｯﾄﾞ 0x%X"
    #define TNB_THREADNAMEFRM2  "ｽﾚｯﾄﾞ 0x%X [%s]"
    #define TNB_THREADTRACETYPE "ｽﾚｯﾄﾞ 0x%X [%s] %s。\n"
  #else
    #define TNB_THREADNAMEFRM1  "スレッド 'Win32 スレッド' (0x%x)"
    #define TNB_THREADNAMEFRM2  "スレッド 'Win32 スレッド' (0x%x) [%s]"
    #define TNB_THREADTRACETYPE "スレッド 'Win32 スレッド' (0x%x) [%s] %s。\n"
  #endif
#endif
 
#endif //_TnbDOXYGEN
 
 
 
class CThreadStatus
{
public:
 
    CThreadStatus(void) : m_hThread(NULL), m_threadId(NULL)
    {
    }
 
    virtual ~CThreadStatus(void)
    {
    }
 
    operator HANDLE(void) const
    {
        return m_hThread;
    }
 
    HANDLE GetHandle(void) const
    {
        return m_hThread;
    }
 
    DWORD GetId(void) const
    {
        if ( ! IsAlive() )
        {
            return 0;
        }
        return m_threadId;
    }
 
    bool IsAlive(void) const
    {
        return m_hThread != NULL;
    }
 
    void SetOwnerHwnd(HWND hWnd)
    {
        m_hOwnerWnd = hWnd;
    }
 
    int GetPriority(void) const
    {
        return IsAlive() ? ::GetThreadPriority(m_hThread) : THREAD_PRIORITY_NORMAL;
    }
 
    bool SetPriority(int priority = THREAD_PRIORITY_NORMAL)
    {
        if ( IsAlive() )
        {
            if ( ::SetThreadPriority(m_hThread, priority) )
            {
                return true;
            }
            _GetLastError("SetThreadPriority");
        }
        return false;
    }
 
    bool PostMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0) const
    {
        bool r = !! ::PostThreadMessage(GetId(), message, wParam, lParam);
        if ( ! r )
        {
            _GetLastError("PostThreadMessage");
        }
        return r;
    }
 
#ifndef _WIN32_WCE
    DWORD_PTR SetAffinityMask(DWORD_PTR affinityMask)
    {
        DWORD_PTR r = ::SetThreadAffinityMask(m_hThread, affinityMask);
        if ( r == 0 )
        {
            _GetLastError("SetThreadAffinityMask");
        }
        return r;
    }
#endif
 
protected:
    HANDLE              m_hThread;          
    DWORD               m_threadId;         
    HWND                m_hOwnerWnd;        
};
 
 
 
class CThread : public CThreadStatus, CCopyImpossible
{
    DEFSUPER(CThreadStatus);
public:
 
    struct IRunner
    {
        virtual ~IRunner(void) {}
 
        IRunner(void) : m_canRunnable(true), m_isOnDemandSuspend(false)
        {
        }
 
        bool IsRunnable(void) const
        {
            if ( m_isOnDemandSuspend )
            {
                m_isOnDemandSuspend = false;
                ::SuspendThread(::GetCurrentThread());
            }
            return m_canRunnable;
        }
 
    protected:
 
        virtual DWORD Run(void) = 0;
 
        virtual void OnSetupThread(void) {}
 
        virtual void OnExitThread(void) {}
 
    private:
        volatile bool       m_canRunnable;      
        mutable bool        m_isOnDemandSuspend;
        CExchangerT<BYTE>   m_excThreadReady;   
        friend class CThread;                   
    };
 
 
    //---------------------------
 
 
    CThread(void) : m_pRunner(NULL), m_lastResult(0)
    {
    }
 
    virtual ~CThread(void)
    {
        Stop();
    }
 
    bool SetRunner(IRunner* pRunner)
    {
        if ( IsAlive() )
        {
            return false;
        }
        m_pRunner = pRunner;
        return true;
    }
 
    void SetOwnerHwnd(HWND hOwner)
    {
        _super::SetOwnerHwnd(hOwner);
    }
 
    DWORD GetThreadResult(void) const
    {
        return m_lastResult;
    }
 
    bool Terminate(DWORD result = 0)
    {
        BOOL r = ::TerminateThread(m_hThread, result);
        _GetLastError("TerminateThread");
        if ( r )
        {
            m_hThread = NULL;
        }
        return !! r;
    }
 
    void StopRequest(void)
    {
        if ( IsAlive() && m_pRunner->m_canRunnable )
        {
            #ifdef _DEBUG
                if ( ! m_threadName.IsEmpty() )
                {
                    TRACE3( TNB_THREADTRACETYPE, m_threadId, m_threadName.Ref(), _T("停止要求") );
                }
            #endif
            //停止要求
            ::ResumeThread(m_hThread);
            SetPriority(THREAD_PRIORITY_NORMAL);
            m_pRunner->m_canRunnable = false;
        }
    }
 
    bool Stop(DWORD dwWait = 15000)
    {
        if ( m_threadId == ::GetCurrentThreadId() )
        {
            ASSERT0( false, "CThread::Stop()", "リスナースレッド処理内で Stop() は使用できません。" );
            return false;
        }
        bool boRc = IsAlive();
        if ( boRc && m_hThread != NULL )
        {
            DWORD dwExitCode;
            if ( ! ::GetExitCodeThread(m_hThread, &dwExitCode) )
            {
                boRc = false;
            }
            else if ( dwExitCode != STILL_ACTIVE )
            {
                #ifdef _DEBUG
                    if ( ! m_threadName.IsEmpty() )
                    {
                        TRACE3( TNB_THREADTRACETYPE, m_threadId, m_threadName.Ref(), _T("既に停止...") );
                    }
                #endif
                boRc = false;
            }
        }
        if ( boRc )
        {
            #ifdef _DEBUG
                if ( ! m_threadName.IsEmpty() )
                {
                    TRACE3( TNB_THREADTRACETYPE, m_threadId, m_threadName.Ref(), _T("停止要求") );
                }
                #if ( _WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400 )
                if ( ::IsDebuggerPresent() )
                {
                    dwWait = 0;
                }
                #endif
            #endif
            //停止要求
            ::ResumeThread(m_hThread);
            SetPriority(THREAD_PRIORITY_NORMAL);
            m_pRunner->m_canRunnable = false;
            //
            if ( dwWait == 0 )
            {
                dwWait = DWORD_MAX;
            }
            else
            {
                dwWait /= 50;
            }
            //スレッド終了待ち
            for ( DWORD i = 0; i < dwWait; i++ )
            {
                m_pRunner->m_canRunnable = false;
                if ( m_hThread == NULL )
                {
                    break;
                }
                DWORD dwExitCode;
                if ( ::GetExitCodeThread(m_hThread, &dwExitCode) )
                {
                    if ( dwExitCode != STILL_ACTIVE )
                    {
                        break;
                    }
                }
                if ( m_hOwnerWnd != NULL )
                {
                    PumpMessage(m_hOwnerWnd);
                }
                ::Sleep(50);
            }
            if ( m_hThread != NULL )
            {
                //終わらなかったらTerm....
                if ( ! ::TerminateThread(m_hThread, 0) )
                {
                    _GetLastError("TerminateThread");
                }
                TRACE0("ThreadをTerminateしました\n");
                #ifdef _DEBUG
                    CWorkMemT<TCHAR> str(1024);
                    if ( ! m_threadName.IsEmpty() )
                    {
                        STRLIB::PrintF(str, 1024, _T("指定時間内に、") _T(TNB_THREADNAMEFRM2) _T("が終了しませんでした。\n          強制終了させました。")
                            ,m_threadId, m_threadName.Ref());
                    }
                    else
                    {
                        STRLIB::PrintF(str, 1024, _T("指定時間内に、") _T(TNB_THREADNAMEFRM1) _T("が終了しませんでした。\n          強制終了させました。")
                            ,m_threadId);
                    }
                    ASSERT1( false, "CThread::Stop()", "%s", str.Ref() );
                #endif
            }
        }
        if ( m_hThread != NULL )
        {
            il_CloseThreadHandle(m_hThread);
            m_hThread = NULL;
        }
        return true;
    }
 
    bool Start(LPCTSTR lpszName = NULL)
    {
        if ( m_pRunner == NULL || IsAlive() )
        {
            return false;
        }
        #ifdef _DEBUG
            m_threadName = lpszName;
        #endif
        //
        m_hThread = il_CreateThread(ms_ThreadMain, this, &m_threadId);
        if ( m_hThread == NULL )
        {
            // スレッド起動失敗
            TRACE0( "スレッド起動失敗");
            return false;
        }
        DWORD r = ::ResumeThread(m_hThread);
        ASSERT( ToInt(r) != -1 );
        IgnoreUnusedValue(r);
        m_pRunner->m_excThreadReady.Exchange(0/*ダミー*/);
        return true;
    }
 
    void Suspend(void)
    {
        if ( m_pRunner != NULL )
        {
            m_pRunner->m_isOnDemandSuspend = true;
        }
    }
 
    bool Resume(void)
    {
        int r = ToInt(::ResumeThread(m_hThread));
        while ( r > 0 )
        {
            r = ToInt(::ResumeThread(m_hThread));
        }
        return r == 0;
    }
 
    static void PumpMessage(HWND hWnd)
    {
        MSG msg;
        while ( ::PeekMessage(&msg, hWnd, 0, 0, PM_NOREMOVE) )
        {
            if ( ! ::GetMessage(&msg, hWnd, 0, 0) )
            {
                break;
            }
            bool r = (WM_KEYFIRST <= msg.message && msg.message <= WM_IME_KEYLAST);
            r |= (WM_MOUSEFIRST <= msg.message && msg.message <= WM_MOUSELAST);
            if ( r )
            {
                TRACE1("Drop Message = %d\n", msg.message);
            }
            else
            {
                ::TranslateMessage(&msg);
                ::DispatchMessage(&msg);
            }
        }
    }
 
private:
    IRunner*            m_pRunner;          
    DWORD               m_lastResult;       
    CSimpleStr          m_threadName;       
 
    static DWORD WINAPI ms_ThreadMain(LPVOID lpPoint)
    {
        CThread* P = static_cast<CThread*>(lpPoint);
        ASSERTLIB(P->m_threadId == ::GetCurrentThreadId());
        P->m_pRunner->m_canRunnable = true;
        P->m_pRunner->OnSetupThread();
        P->m_pRunner->m_excThreadReady.Exchange(0/*ダミー*/);
        #ifdef _DEBUG
            if ( ! P->m_threadName.IsEmpty() )
            {
                TRACE3( TNB_THREADTRACETYPE, P->m_threadId, P->m_threadName.Ref(), _T("開始"));
            }
        #endif
        P->m_lastResult = P->m_pRunner->Run();
        #ifdef _DEBUG
            if ( ! P->m_threadName.IsEmpty() )
            {
                TRACE3( TNB_THREADTRACETYPE, P->m_threadId, P->m_threadName.Ref(), _T("終了"));
            }
        #endif
        P->m_pRunner->OnExitThread();
        il_CloseThreadHandle(P->m_hThread);
        P->m_hThread = NULL;
        P->m_threadId = 0;
        il_ExitThread(P->m_lastResult);
        return P->m_lastResult;
    }
};
 
 
 
class CThreadlet
{
public:
 
    struct IRunner
    {
        virtual ~IRunner(void) {}
        virtual void Run(LPARAM lParam) = 0;
    };
 
    static bool Start(LPARAM lParam, IRunner* piRunner, bool withDelete = true, int priority = THREAD_PRIORITY_NORMAL)
    {
        CThreadlet* P = new CThreadlet;
        P->m_pRunner = piRunner;
        P->m_lParam = lParam;
        P->m_withDelete = withDelete;
        //
        DWORD dwThreadId;
        HANDLE hThread = il_CreateThread(ms_ThreadMain, P, &dwThreadId);
        if ( hThread == NULL )
        {
            // スレッド起動失敗
            TRACE0( "スレッド起動失敗");
            if ( P->m_withDelete )
            {
                delete P->m_pRunner;
            }
            delete P;
            return false;
        }
        ::SetThreadPriority(hThread, priority);
        DWORD r = ::ResumeThread(hThread);
        ASSERT(ToInt(r) != -1);
        IgnoreUnusedValue(r);
        il_CloseThreadHandle(hThread);
        P->m_excThreadReady.Exchange(0/*ダミー*/);
        return true;
    }
 
private:
 
    CExchangerT<BYTE>   m_excThreadReady;   
    IRunner*            m_pRunner;          
    bool                m_withDelete;       
    LPARAM              m_lParam;           
    static DWORD WINAPI ms_ThreadMain(LPVOID lpPoint)
    {
        CThreadlet* P = static_cast<CThreadlet*>(lpPoint);
        P->m_excThreadReady.Exchange(0/*ダミー*/);
        P->m_pRunner->Run(P->m_lParam);
        ::Sleep(200);
        if ( P->m_withDelete )
        {
            delete P->m_pRunner;
        }
        delete P;
        il_ExitThread(0);
        return 0;
    }
 
    CThreadlet(void) {}
};
 
 
 
class CTemporarilyThreadPriority
{
public:
    
    CTemporarilyThreadPriority(int priority = THREAD_PRIORITY_TIME_CRITICAL)
        : m_hThread(::GetCurrentThread())
    {
        m_Init(priority);
    }
 
    CTemporarilyThreadPriority(HANDLE hThread, int priority = THREAD_PRIORITY_TIME_CRITICAL) 
        : m_hThread(hThread)
    {
        m_Init(priority);
    }
    
    ~CTemporarilyThreadPriority(void)
    {
        Restore();
    }
 
    void Restore(void)
    {
        if ( m_hThread != NULL )
        {
            ::SetThreadPriority(m_hThread, m_priority);
            m_hThread = NULL;
        }
    }
 
private:
    void m_Init(int p)
    {
        m_priority = ::GetThreadPriority(m_hThread);
        ::SetThreadPriority(m_hThread, p);
        ASSERT( ::GetThreadPriority(m_hThread) == p );
    }
    HANDLE  m_hThread;      
    int     m_priority;     
};
 
 
 
}; // TNB