X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/696d13ee0e378e3f14eb624cae2335bc05f74d06..db414879d45f5da2be534a0f523b0506f2ab1183:/include/wx/thread.h diff --git a/include/wx/thread.h b/include/wx/thread.h index b95652dcac..7ee8361ee9 100644 --- a/include/wx/thread.h +++ b/include/wx/thread.h @@ -22,11 +22,6 @@ #if wxUSE_THREADS -// Windows headers define it -#ifdef Yield - #undef Yield -#endif - // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -76,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 { @@ -110,11 +120,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 @@ -166,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: @@ -209,35 +219,46 @@ 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(__WXMAC__) +#if !defined(__WINDOWS__) #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(); + // 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(); private: #if wxCRITSECT_IS_MUTEX wxMutex m_mutex; -#elif defined(__WXMSW__) +#elif defined(__WINDOWS__) // we can't allocate any memory in the ctor, so use placement new - // unfortunately, we have to hardcode the sizeof() here because we can't // include windows.h from this public header and we also have to use the @@ -261,19 +282,19 @@ private: wxCritSectBuffer m_buffer; }; -#elif defined(__WXMAC__) - void *m_critRegion ; #endif // Unix&OS2/Win32 - DECLARE_NO_COPY_CLASS(wxCriticalSection) + wxDECLARE_NO_COPY_CLASS(wxCriticalSection); }; #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(); } + inline bool wxCriticalSection::TryEnter() { return m_mutex.TryLock() == wxMUTEX_NO_ERROR; } inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); } #endif // wxCRITSECT_IS_MUTEX @@ -299,7 +320,7 @@ public: private: wxCriticalSection& m_critsect; - DECLARE_NO_COPY_CLASS(wxCriticalSectionLocker) + wxDECLARE_NO_COPY_CLASS(wxCriticalSectionLocker); }; // ---------------------------------------------------------------------------- @@ -362,7 +383,7 @@ public: private: wxConditionInternal *m_internal; - DECLARE_NO_COPY_CLASS(wxCondition) + wxDECLARE_NO_COPY_CLASS(wxCondition); }; #if WXWIN_COMPATIBILITY_2_6 @@ -407,7 +428,7 @@ public: private: wxSemaphoreInternal *m_internal; - DECLARE_NO_COPY_CLASS(wxSemaphore) + wxDECLARE_NO_COPY_CLASS(wxSemaphore); }; // ---------------------------------------------------------------------------- @@ -445,14 +466,24 @@ 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(); // 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() @@ -464,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 @@ -504,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. @@ -553,10 +585,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 @@ -575,12 +605,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; @@ -600,8 +653,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: @@ -628,27 +681,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); } @@ -658,16 +728,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; } // ---------------------------------------------------------------------------- @@ -693,16 +790,19 @@ 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; +// 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_LOCKER(name, cs) struct wxDummyCSLocker##name // if there is only one thread, it is always the main one inline bool wxIsMainThread() { return true; } @@ -744,7 +844,7 @@ public: #if wxUSE_THREADS -#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__OS2__) || defined(__EMX__) +#if defined(__WINDOWS__) || 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 @@ -756,10 +856,12 @@ 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 // MSW, Mac, OS/2 +#endif +#endif // MSW, OS/2 #endif // wxUSE_THREADS