X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c096f614b94fc6462f6339e4aec6d0b673897e13..2903e6998a46a0b3504da30e21a9c28b344680ae:/include/wx/thread.h diff --git a/include/wx/thread.h b/include/wx/thread.h index 7d61023195..0b237cb4f2 100644 --- a/include/wx/thread.h +++ b/include/wx/thread.h @@ -22,16 +22,6 @@ #if wxUSE_THREADS -// only for wxUSE_THREADS - otherwise we'd get undefined symbols -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma interface "thread.h" -#endif - -// Windows headers define it -#ifdef Yield - #undef Yield -#endif - // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -43,6 +33,7 @@ enum wxMutexError wxMUTEX_DEAD_LOCK, // mutex is already locked by the calling thread wxMUTEX_BUSY, // mutex is already locked by another thread wxMUTEX_UNLOCKED, // attempt to unlock a mutex which is not locked + wxMUTEX_TIMEOUT, // LockTimeout() has timed out wxMUTEX_MISC_ERROR // any other error }; @@ -114,11 +105,11 @@ enum wxMutexType }; // forward declarations -class WXDLLIMPEXP_BASE wxThreadHelper; -class WXDLLIMPEXP_BASE wxConditionInternal; -class WXDLLIMPEXP_BASE wxMutexInternal; -class WXDLLIMPEXP_BASE wxSemaphoreInternal; -class WXDLLIMPEXP_BASE wxThreadInternal; +class WXDLLIMPEXP_FWD_BASE wxThreadHelper; +class WXDLLIMPEXP_FWD_BASE wxConditionInternal; +class WXDLLIMPEXP_FWD_BASE wxMutexInternal; +class WXDLLIMPEXP_FWD_BASE wxSemaphoreInternal; +class WXDLLIMPEXP_FWD_BASE wxThreadInternal; // ---------------------------------------------------------------------------- // A mutex object is a synchronization object whose state is set to signaled @@ -154,6 +145,10 @@ public: // The caller must call Unlock() later if Lock() returned wxMUTEX_NO_ERROR. wxMutexError Lock(); + // Same as Lock() but return wxMUTEX_TIMEOUT if the mutex can't be locked + // during the given number of milliseconds + wxMutexError LockTimeout(unsigned long ms); + // Try to lock the mutex: if it is currently locked, return immediately // with an error. Otherwise the caller must call Unlock(). wxMutexError TryLock(); @@ -212,22 +207,30 @@ private: #if !defined(__WXMSW__) #define wxCRITSECT_IS_MUTEX 1 - #define wxCRITSECT_INLINE inline + #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(); @@ -268,7 +271,8 @@ private: #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(); } @@ -279,7 +283,7 @@ private: #undef wxCRITSECT_IS_MUTEX // wxCriticalSectionLocker is the same to critical sections as wxMutexLocker is -// to th mutexes +// to mutexes class WXDLLIMPEXP_BASE wxCriticalSectionLocker { public: @@ -319,7 +323,7 @@ public: bool IsOk() const; // NB: the associated mutex MUST be locked beforehand by the calling thread - // + // // it atomically releases the lock on the associated mutex // and starts waiting to be woken up by a Signal()/Broadcast() // once its signaled, then it will wait until it can reacquire @@ -327,19 +331,19 @@ public: wxCondError Wait(); // exactly as Wait() except that it may also return if the specified - // timeout ellapses even if the condition hasn't been signalled: in this + // timeout elapses even if the condition hasn't been signalled: in this // case, the return value is false, otherwise (i.e. in case of a normal // return) it is true - // - // the timeeout parameter specifies a interval that needs to be waited in - // milliseconds + // + // the timeout parameter specifies an interval that needs to be waited for + // in milliseconds wxCondError WaitTimeout(unsigned long milliseconds); // NB: the associated mutex may or may not be locked by the calling thread // // this method unblocks one thread if any are blocking on the condition. // if no thread is blocking in Wait(), then the signal is NOT remembered - // The thread which was blocking on Wait(), will then reacquire the lock + // The thread which was blocking on Wait() will then reacquire the lock // on the associated mutex object before returning wxCondError Signal(); @@ -347,14 +351,15 @@ public: // // this method unblocks all threads if any are blocking on the condition. // if no thread is blocking in Wait(), then the signal is NOT remembered - // The threads which were blocking on Wait(), will then reacquire the lock + // The threads which were blocking on Wait() will then reacquire the lock // on the associated mutex object before returning. wxCondError Broadcast(); +#if WXWIN_COMPATIBILITY_2_6 // deprecated version, don't use - bool Wait(unsigned long milliseconds) - { return WaitTimeout(milliseconds) == wxCOND_NO_ERROR; } + wxDEPRECATED( bool Wait(unsigned long milliseconds) ); +#endif // WXWIN_COMPATIBILITY_2_6 private: wxConditionInternal *m_internal; @@ -362,6 +367,11 @@ private: DECLARE_NO_COPY_CLASS(wxCondition) }; +#if WXWIN_COMPATIBILITY_2_6 + inline bool wxCondition::Wait(unsigned long milliseconds) + { return WaitTimeout(milliseconds) == wxCOND_NO_ERROR; } +#endif // WXWIN_COMPATIBILITY_2_6 + // ---------------------------------------------------------------------------- // wxSemaphore: a counter limiting the number of threads concurrently accessing // a shared resource @@ -390,7 +400,7 @@ public: wxSemaError TryWait(); // same as Wait(), but as a timeout limit, returns wxSEMA_NO_ERROR if the - // semaphore was acquired and wxSEMA_TIMEOUT if the timeout has ellapsed + // semaphore was acquired and wxSEMA_TIMEOUT if the timeout has elapsed wxSemaError WaitTimeout(unsigned long milliseconds); // increments the semaphore count and signals one of the waiting threads @@ -403,7 +413,7 @@ private: }; // ---------------------------------------------------------------------------- -// wxThread: class encpasulating a thread of execution +// wxThread: class encapsulating a thread of execution // ---------------------------------------------------------------------------- // there are two different kinds of threads: joinable and detached (default) @@ -439,12 +449,12 @@ public: // Returns true if current thread is the main thread. static bool IsMain(); - // Release the rest of our time slice leting the other threads run + // Release the rest of our time slice letting the other threads run static void Yield(); // Sleep during the specified period of time in milliseconds // - // NB: at least under MSW worker threads can not call ::wxSleep()! + // This is the same as wxMilliSleep(). static void Sleep(unsigned long milliseconds); // get the number of system CPUs - useful with SetConcurrency() @@ -505,9 +515,9 @@ public: ExitCode Wait(); // kills the thread without giving it any chance to clean up - should - // not be used in normal circumstances, use Delete() instead. It is a - // dangerous function that should only be used in the most extreme - // cases! + // not be used under normal circumstances, use Delete() instead. + // It is a dangerous function that should only be used in the most + // extreme cases! // // The wxThread object is deleted by Kill() if the thread is // detachable, but you still have to delete it manually for joinable @@ -545,10 +555,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 @@ -572,6 +580,11 @@ private: 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; // the (platform-dependent) thread class implementation @@ -592,8 +605,8 @@ class WXDLLIMPEXP_BASE wxThreadHelperThread : public wxThread public: // constructor only creates the C++ thread object and doesn't create (or // start) the real thread - wxThreadHelperThread(wxThreadHelper& owner) - : wxThread(wxTHREAD_JOINABLE), m_owner(owner) + wxThreadHelperThread(wxThreadHelper& owner, wxThreadKind kind) + : wxThread(kind), m_owner(owner) { } protected: @@ -620,27 +633,44 @@ class WXDLLIMPEXP_BASE wxThreadHelper private: void KillThread() { + // 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(); - delete m_thread; + + if ( m_kind == wxTHREAD_JOINABLE ) + delete m_thread; + + m_thread = NULL; } } public: // constructor only initializes m_thread to NULL - wxThreadHelper() : m_thread(NULL) { } + wxThreadHelper(wxThreadKind kind = wxTHREAD_JOINABLE) + : m_thread(NULL), m_kind(kind) { } // 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_thread = new wxThreadHelperThread(*this); + m_kind = kind; + m_thread = new wxThreadHelperThread(*this, m_kind); return m_thread->Create(stackSize); } @@ -650,16 +680,43 @@ public: virtual void *Entry() = 0; // returns a pointer to the thread which can be used to call Run() - wxThread *GetThread() const { return m_thread; } + wxThread *GetThread() const + { + wxCriticalSectionLocker locker((wxCriticalSection&)m_critSection); + + wxThread* thread = m_thread; + + return thread; + } 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() { - return m_owner.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; } // ---------------------------------------------------------------------------- @@ -685,16 +742,17 @@ inline bool wxIsMainThread() { return wxThread::IsMain(); } #else // !wxUSE_THREADS // no thread support -inline void WXDLLIMPEXP_BASE wxMutexGuiEnter() { } -inline void WXDLLIMPEXP_BASE wxMutexGuiLeave() { } +inline void wxMutexGuiEnter() { } +inline void wxMutexGuiLeave() { } // macros for entering/leaving critical sections which may be used without // having to take them inside "#if wxUSE_THREADS" -#define wxENTER_CRIT_SECT(cs) -#define wxLEAVE_CRIT_SECT(cs) -#define wxCRIT_SECT_DECLARE(cs) -#define wxCRIT_SECT_DECLARE_MEMBER(cs) -#define wxCRIT_SECT_LOCKER(name, cs) +// (the implementation uses dummy structs to force semicolon after the macro) +#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_LOCKER(name, cs) struct wxDummyCSLocker##name // if there is only one thread, it is always the main one inline bool wxIsMainThread() { return true; } @@ -736,7 +794,7 @@ public: #if wxUSE_THREADS -#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__) || defined(__EMX__) +#if defined(__WXMSW__) || defined(__OS2__) || defined(__EMX__) // 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 @@ -745,17 +803,14 @@ public: // returns true if the main thread has GUI lock extern bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread(); -#ifndef __WXPM__ // wakes up the main thread if it's sleeping inside ::GetMessage() extern void WXDLLIMPEXP_BASE wxWakeUpMainThread(); -#endif // !OS/2 // 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 // MSW, Mac, OS/2 +#endif // MSW, OS/2 #endif // wxUSE_THREADS #endif // _WX_THREAD_H_ -