X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ca9e2173a63d0e5a56fa9c2f8e1ff6ff32a9b71f..5cbda74b6606482f5286a5599fc60f3f91995a52:/include/wx/thread.h diff --git a/include/wx/thread.h b/include/wx/thread.h index 4eed53d1bf..ce17e6438d 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: @@ -207,24 +222,29 @@ private: #if !defined(__WXMSW__) #define wxCRITSECT_IS_MUTEX 1 -#ifdef __WXMAC__ - #define wxCRITSECT_INLINE -#else - #define wxCRITSECT_INLINE inline -#endif + #define wxCRITSECT_INLINE WXEXPORT inline #else // MSW #define wxCRITSECT_IS_MUTEX 0 #define wxCRITSECT_INLINE #endif // MSW/!MSW +enum wxCriticalSectionType +{ + // recursive critical section + wxCRITSEC_DEFAULT, + + // non-recursive critical section + wxCRITSEC_NON_RECURSIVE +}; + // you should consider wxCriticalSectionLocker whenever possible instead of // directly working with wxCriticalSection class - it is safer class WXDLLIMPEXP_BASE wxCriticalSection { public: // ctor & dtor - wxCRITSECT_INLINE wxCriticalSection(); + wxCRITSECT_INLINE wxCriticalSection( wxCriticalSectionType critSecType = wxCRITSEC_DEFAULT ); wxCRITSECT_INLINE ~wxCriticalSection(); // enter the section (the same as locking a mutex) wxCRITSECT_INLINE void Enter(); @@ -261,12 +281,13 @@ private: }; #endif // Unix&OS2/Win32 - DECLARE_NO_COPY_CLASS(wxCriticalSection) + wxDECLARE_NO_COPY_CLASS(wxCriticalSection); }; -#if wxCRITSECT_IS_MUTEX && !defined(__WXMAC__) +#if wxCRITSECT_IS_MUTEX // implement wxCriticalSection using mutexes - inline wxCriticalSection::wxCriticalSection() { } + inline wxCriticalSection::wxCriticalSection( wxCriticalSectionType critSecType ) + : m_mutex( critSecType == wxCRITSEC_DEFAULT ? wxMUTEX_RECURSIVE : wxMUTEX_DEFAULT ) { } inline wxCriticalSection::~wxCriticalSection() { } inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); } @@ -295,7 +316,7 @@ public: private: wxCriticalSection& m_critsect; - DECLARE_NO_COPY_CLASS(wxCriticalSectionLocker) + wxDECLARE_NO_COPY_CLASS(wxCriticalSectionLocker); }; // ---------------------------------------------------------------------------- @@ -358,7 +379,7 @@ public: private: wxConditionInternal *m_internal; - DECLARE_NO_COPY_CLASS(wxCondition) + wxDECLARE_NO_COPY_CLASS(wxCondition); }; #if WXWIN_COMPATIBILITY_2_6 @@ -403,7 +424,7 @@ public: private: wxSemaphoreInternal *m_internal; - DECLARE_NO_COPY_CLASS(wxSemaphore) + wxDECLARE_NO_COPY_CLASS(wxSemaphore); }; // ---------------------------------------------------------------------------- @@ -441,7 +462,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(); @@ -460,7 +491,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 @@ -500,13 +531,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. @@ -549,10 +581,8 @@ public: // identifies a thread inside a process wxThreadIdType GetId() const; - // called when the thread exits - in the context of this thread - // - // NB: this function will not be called if the thread is Kill()ed - virtual void OnExit() { } + wxThreadKind GetKind() const + { return m_isDetached ? wxTHREAD_DETACHED : wxTHREAD_JOINABLE; } // Returns true if the thread was asked to terminate: this function should // be called by the thread from time to time, otherwise the main thread @@ -571,12 +601,35 @@ 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&); wxThread& operator=(const wxThread&); + // called when the thread exits - in the context of this thread + // + // NB: this function will not be called if the thread is Kill()ed + 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; @@ -624,20 +677,19 @@ 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 ) { m_thread->Kill(); - + if ( m_kind == wxTHREAD_JOINABLE ) delete m_thread; - + m_thread = NULL; } } @@ -650,12 +702,18 @@ public: // destructor deletes m_thread virtual ~wxThreadHelper() { KillThread(); } +#if WXWIN_COMPATIBILITY_2_8 + wxDEPRECATED( wxThreadError Create(unsigned int stackSize = 0) ); +#endif + // create a new thread (and optionally set the stack size on platforms that // support/need that), call Run() to start it - wxThreadError Create(unsigned int stackSize = 0) + wxThreadError CreateThread(wxThreadKind kind = wxTHREAD_JOINABLE, + unsigned int stackSize = 0) { KillThread(); + m_kind = kind; m_thread = new wxThreadHelperThread(*this, m_kind); return m_thread->Create(stackSize); @@ -669,9 +727,9 @@ public: wxThread *GetThread() const { wxCriticalSectionLocker locker((wxCriticalSection&)m_critSection); - + wxThread* thread = m_thread; - + return thread; } @@ -679,24 +737,29 @@ protected: wxThread *m_thread; wxThreadKind m_kind; wxCriticalSection m_critSection; // To guard the m_thread variable - + friend class wxThreadHelperThread; }; +#if WXWIN_COMPATIBILITY_2_8 +inline wxThreadError wxThreadHelper::Create(unsigned int stackSize) +{ return CreateThread(m_kind, stackSize); } +#endif + // call Entry() in owner, put it down here to avoid circular declarations inline void *wxThreadHelperThread::Entry() { void * const result = m_owner.Entry(); - + wxCriticalSectionLocker locker(m_owner.m_critSection); - + // Detached thread will be deleted after returning, so make sure // wxThreadHelper::GetThread will not return an invalid pointer. // And that wxThreadHelper::KillThread will not try to kill // an already deleted thread if ( m_owner.m_kind == wxTHREAD_DETACHED ) m_owner.m_thread = NULL; - + return result; } @@ -728,11 +791,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 @@ -775,7 +840,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 @@ -787,9 +852,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