X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3d5930b5ea5cd28d97ca9df147cd48bc51061480..96dc06fdcece9307ffb0c23bb6944ff03c526808:/include/wx/thread.h?ds=inline diff --git a/include/wx/thread.h b/include/wx/thread.h index 9e07b4e821..9718c3998e 100644 --- a/include/wx/thread.h +++ b/include/wx/thread.h @@ -71,6 +71,21 @@ enum wxThreadKind wxTHREAD_JOINABLE }; +enum wxThreadWait +{ + wxTHREAD_WAIT_BLOCK, + wxTHREAD_WAIT_YIELD, // process events while waiting; MSW only + + // For compatibility reasons we use wxTHREAD_WAIT_YIELD by default as this + // was the default behaviour of wxMSW 2.8 but it should be avoided as it's + // dangerous and not portable. +#if WXWIN_COMPATIBILITY_2_8 + wxTHREAD_WAIT_DEFAULT = wxTHREAD_WAIT_YIELD +#else + wxTHREAD_WAIT_DEFAULT = wxTHREAD_WAIT_BLOCK +#endif +}; + // defines the interval of priority enum { @@ -161,7 +176,7 @@ protected: friend class wxConditionInternal; - DECLARE_NO_COPY_CLASS(wxMutex) + wxDECLARE_NO_COPY_CLASS(wxMutex); }; // a helper class which locks the mutex in the ctor and unlocks it in the dtor: @@ -234,6 +249,9 @@ public: // enter the section (the same as locking a mutex) wxCRITSECT_INLINE void Enter(); + // try to enter the section (the same as trying to lock a mutex) + wxCRITSECT_INLINE bool TryEnter(); + // leave the critical section (same as unlocking a mutex) wxCRITSECT_INLINE void Leave(); @@ -266,7 +284,7 @@ private: }; #endif // Unix&OS2/Win32 - DECLARE_NO_COPY_CLASS(wxCriticalSection) + wxDECLARE_NO_COPY_CLASS(wxCriticalSection); }; #if wxCRITSECT_IS_MUTEX @@ -276,6 +294,7 @@ private: inline wxCriticalSection::~wxCriticalSection() { } inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); } + inline bool wxCriticalSection::TryEnter() { return m_mutex.TryLock() == wxMUTEX_NO_ERROR; } inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); } #endif // wxCRITSECT_IS_MUTEX @@ -301,7 +320,7 @@ public: private: wxCriticalSection& m_critsect; - DECLARE_NO_COPY_CLASS(wxCriticalSectionLocker) + wxDECLARE_NO_COPY_CLASS(wxCriticalSectionLocker); }; // ---------------------------------------------------------------------------- @@ -364,7 +383,7 @@ public: private: wxConditionInternal *m_internal; - DECLARE_NO_COPY_CLASS(wxCondition) + wxDECLARE_NO_COPY_CLASS(wxCondition); }; #if WXWIN_COMPATIBILITY_2_6 @@ -409,7 +428,7 @@ public: private: wxSemaphoreInternal *m_internal; - DECLARE_NO_COPY_CLASS(wxSemaphore) + wxDECLARE_NO_COPY_CLASS(wxSemaphore); }; // ---------------------------------------------------------------------------- @@ -447,7 +466,17 @@ public: static wxThread *This(); // Returns true if current thread is the main thread. - static bool IsMain(); + // + // Notice that it also returns true if main thread id hadn't been + // initialized yet on the assumption that it's too early in wx startup + // process for any other threads to have been created in this case. + static bool IsMain() + { + return !ms_idMainThread || GetCurrentId() == ms_idMainThread; + } + + // Return the main thread id + static wxThreadIdType GetMainId() { return ms_idMainThread; } // Release the rest of our time slice letting the other threads run static void Yield(); @@ -466,7 +495,7 @@ public: // Get the platform specific thread ID and return as a long. This // can be used to uniquely identify threads, even if they are not // wxThreads. This is used by wxPython. - static wxThreadIdType GetCurrentId(); + static wxThreadIdType GetCurrentId(); // sets the concurrency level: this is, roughly, the number of threads // the system tries to schedule to run in parallel. 0 means the @@ -506,13 +535,14 @@ public: // does it! // // will fill the rc pointer with the thread exit code if it's !NULL - wxThreadError Delete(ExitCode *rc = (ExitCode *)NULL); + wxThreadError Delete(ExitCode *rc = NULL, + wxThreadWait waitMode = wxTHREAD_WAIT_DEFAULT); // waits for a joinable thread to finish and returns its exit code // // Returns (ExitCode)-1 on error (for example, if the thread is not // joinable) - ExitCode Wait(); + ExitCode Wait(wxThreadWait waitMode = wxTHREAD_WAIT_DEFAULT); // kills the thread without giving it any chance to clean up - should // not be used under normal circumstances, use Delete() instead. @@ -575,6 +605,19 @@ protected: // of this thread. virtual void *Entry() = 0; + + // Callbacks which may be overridden by the derived class to perform some + // specific actions when the thread is deleted or killed. By default they + // do nothing. + + // This one is called by Delete() before actually deleting the thread and + // is executed in the context of the thread that called Delete(). + virtual void OnDelete() {} + + // This one is called by Kill() before killing the thread and is executed + // in the context of the thread that called Kill(). + virtual void OnKill() {} + private: // no copy ctor/assignment operator wxThread(const wxThread&); @@ -586,6 +629,11 @@ private: virtual void OnExit() { } friend class wxThreadInternal; + friend class wxThreadModule; + + + // the main thread identifier, should be set on startup + static wxThreadIdType ms_idMainThread; // the (platform-dependent) thread class implementation wxThreadInternal *m_internal; @@ -633,11 +681,10 @@ class WXDLLIMPEXP_BASE wxThreadHelper private: void KillThread() { - // If detached thread is about to finish, it will set - // m_thread to NULL so don't delete it then - // But if KillThread is called before detached thread - // sets it to NULL, then the thread object still - // exists and can be killed + // If wxThreadHelperThread is detached and is about to finish, it will + // set m_thread to NULL so don't delete it then. + // But if KillThread is called before wxThreadHelperThread (in detached mode) + // sets it to NULL, then the thread object still exists and can be killed wxCriticalSectionLocker locker(m_critSection); if ( m_thread ) @@ -748,11 +795,13 @@ inline void wxMutexGuiLeave() { } // macros for entering/leaving critical sections which may be used without // having to take them inside "#if wxUSE_THREADS" -// (the implementation uses dummy structs to force semicolon after the macro) +// (the implementation uses dummy structs to force semicolon after the macro; +// also notice that Watcom doesn't like declaring a struct as a member so we +// need to actually define it in wxCRIT_SECT_DECLARE_MEMBER) #define wxENTER_CRIT_SECT(cs) do {} while (0) #define wxLEAVE_CRIT_SECT(cs) do {} while (0) #define wxCRIT_SECT_DECLARE(cs) struct wxDummyCS##cs -#define wxCRIT_SECT_DECLARE_MEMBER(cs) struct wxDummyCSMember##cs +#define wxCRIT_SECT_DECLARE_MEMBER(cs) struct wxDummyCSMember##cs { } #define wxCRIT_SECT_LOCKER(name, cs) struct wxDummyCSLocker##name // if there is only one thread, it is always the main one @@ -795,7 +844,7 @@ public: #if wxUSE_THREADS -#if defined(__WXMSW__) || defined(__OS2__) || defined(__EMX__) +#if defined(__WXMSW__) || defined(__OS2__) || defined(__EMX__) || defined(__WXOSX__) // unlock GUI if there are threads waiting for and lock it back when // there are no more of them - should be called periodically by the main // thread @@ -807,9 +856,11 @@ public: // wakes up the main thread if it's sleeping inside ::GetMessage() extern void WXDLLIMPEXP_BASE wxWakeUpMainThread(); +#ifndef __WXOSX__ // return true if the main thread is waiting for some other to terminate: // wxApp then should block all "dangerous" messages extern bool WXDLLIMPEXP_BASE wxIsWaitingForThread(); +#endif #endif // MSW, OS/2 #endif // wxUSE_THREADS