X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/bb24c68f3502746147337c3f502cc1c957bcfb35..6619edf0ea94b6623f1c7e7875d5ca8abac23382:/include/wx/thread.h diff --git a/include/wx/thread.h b/include/wx/thread.h index 24046e1d5a..10c30ead59 100644 --- a/include/wx/thread.h +++ b/include/wx/thread.h @@ -22,11 +22,6 @@ #if wxUSE_THREADS -// only for wxUSE_THREADS - otherwise we'd get undefined symbols -#if defined(__GNUG__) && !defined(__APPLE__) - #pragma interface "thread.h" -#endif - // Windows headers define it #ifdef Yield #undef Yield @@ -43,6 +38,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,10 +110,11 @@ enum wxMutexType }; // forward declarations -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 @@ -153,6 +150,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(); @@ -176,10 +177,10 @@ class WXDLLIMPEXP_BASE wxMutexLocker public: // lock the mutex in the ctor wxMutexLocker(wxMutex& mutex) - : m_isOk(FALSE), m_mutex(mutex) + : m_isOk(false), m_mutex(mutex) { m_isOk = ( m_mutex.Lock() == wxMUTEX_NO_ERROR ); } - // returns TRUE if mutex was successfully locked in ctor + // returns true if mutex was successfully locked in ctor bool IsOk() const { return m_isOk; } @@ -208,11 +209,11 @@ private: // in order to avoid any overhead under platforms where critical sections are // just mutexes make all wxCriticalSection class functions inline -#if !defined(__WXMSW__) && !defined(__WXPM__) +#if !defined(__WXMSW__) && !defined(__WXMAC__) #define wxCRITSECT_IS_MUTEX 1 #define wxCRITSECT_INLINE inline -#else // MSW || OS2 +#else // MSW #define wxCRITSECT_IS_MUTEX 0 #define wxCRITSECT_INLINE @@ -248,7 +249,11 @@ private: // finally, we need this typedef instead of declaring m_buffer directly // because otherwise the assert mentioned above wouldn't compile with some // compilers (notably CodeWarrior 8) +#ifdef __WIN64__ + typedef char wxCritSectBuffer[40]; +#else // __WIN32__ typedef char wxCritSectBuffer[24]; +#endif union { unsigned long m_dummy1; @@ -256,9 +261,9 @@ private: wxCritSectBuffer m_buffer; }; -#else - // nothing for OS/2 -#endif // Unix/Win32/OS2 +#elif defined(__WXMAC__) + void *m_critRegion ; +#endif // Unix&OS2/Win32 DECLARE_NO_COPY_CLASS(wxCriticalSection) }; @@ -276,7 +281,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: @@ -312,11 +317,11 @@ public: // dtor is not virtual, don't use this class polymorphically ~wxCondition(); - // return TRUE if the condition has been created successfully + // return true if the condition has been created successfully 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 @@ -324,19 +329,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 - // 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 + // 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 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(); @@ -344,14 +349,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; @@ -359,6 +365,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 @@ -374,7 +385,7 @@ public: // dtor is not virtual, don't use this class polymorphically ~wxSemaphore(); - // return TRUE if the semaphore has been created successfully + // return true if the semaphore has been created successfully bool IsOk() const; // wait indefinitely, until the semaphore count goes beyond 0 @@ -387,7 +398,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 @@ -400,7 +411,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) @@ -436,7 +447,7 @@ 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 @@ -460,7 +471,7 @@ public: // default value (usually acceptable, but may not yield the best // performance for this process) // - // Returns TRUE on success, FALSE otherwise (if not implemented, for + // Returns true on success, false otherwise (if not implemented, for // example) static bool SetConcurrency(size_t level); @@ -502,9 +513,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 @@ -547,16 +558,16 @@ public: // NB: this function will not be called if the thread is Kill()ed virtual void OnExit() { } + // 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 + // will be left forever in Delete()! + virtual bool TestDestroy(); + // dtor is public, but the detached threads should never be deleted - use // Delete() instead (or leave the thread terminate by itself) virtual ~wxThread(); protected: - // 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 - // will be left forever in Delete()! - bool TestDestroy(); - // exits from the current thread - can be called only from this thread void Exit(ExitCode exitcode = 0); @@ -581,6 +592,84 @@ private: bool m_isDetached; }; +// wxThreadHelperThread class +// -------------------------- + +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) + { } + +protected: + // entry point for the thread -- calls Entry() in owner. + virtual void *Entry(); + +private: + // the owner of the thread + wxThreadHelper& m_owner; + + // no copy ctor/assignment operator + wxThreadHelperThread(const wxThreadHelperThread&); + wxThreadHelperThread& operator=(const wxThreadHelperThread&); +}; + +// ---------------------------------------------------------------------------- +// wxThreadHelper: this class implements the threading logic to run a +// background task in another object (such as a window). It is a mix-in: just +// derive from it to implement a threading background task in your class. +// ---------------------------------------------------------------------------- + +class WXDLLIMPEXP_BASE wxThreadHelper +{ +private: + void KillThread() + { + if ( m_thread ) + { + m_thread->Kill(); + delete m_thread; + } + } + +public: + // constructor only initializes m_thread to NULL + wxThreadHelper() : m_thread(NULL) { } + + // destructor deletes m_thread + virtual ~wxThreadHelper() { KillThread(); } + + // 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) + { + KillThread(); + + m_thread = new wxThreadHelperThread(*this); + + return m_thread->Create(stackSize); + } + + // entry point for the thread - called by Run() and executes in the context + // of this thread. + virtual void *Entry() = 0; + + // returns a pointer to the thread which can be used to call Run() + wxThread *GetThread() const { return m_thread; } + +protected: + wxThread *m_thread; +}; + +// call Entry() in owner, put it down here to avoid circular declarations +inline void *wxThreadHelperThread::Entry() +{ + return m_owner.Entry(); +} + // ---------------------------------------------------------------------------- // Automatic initialization // ---------------------------------------------------------------------------- @@ -604,8 +693,8 @@ 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" @@ -655,21 +744,19 @@ public: #if wxUSE_THREADS -#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__) +#if defined(__WXMSW__) || defined(__WXMAC__) || 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 extern void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter(); - // returns TRUE if the main thread has GUI lock + // 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: + // 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 @@ -677,4 +764,3 @@ public: #endif // wxUSE_THREADS #endif // _WX_THREAD_H_ -