X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c0c133e13b36a923c65f94499554e432bc3a0daa..66c2bf7b1d9326fb650acfaae22ec50528cfbf7c:/include/wx/thread.h?ds=inline diff --git a/include/wx/thread.h b/include/wx/thread.h index fc0ac2759c..3d3a23a133 100644 --- a/include/wx/thread.h +++ b/include/wx/thread.h @@ -5,7 +5,6 @@ // Modified by: Vadim Zeitlin (modifications partly inspired by omnithreads // package from Olivetti & Oracle Research Laboratory) // Created: 04/13/98 -// RCS-ID: $Id$ // Copyright: (c) Guilhem Lavaux // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -71,12 +70,27 @@ enum wxThreadKind wxTHREAD_JOINABLE }; -// defines the interval of priority +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 +}; + +// Obsolete synonyms for wxPRIORITY_XXX for backwards compatibility-only enum { - WXTHREAD_MIN_PRIORITY = 0u, - WXTHREAD_DEFAULT_PRIORITY = 50u, - WXTHREAD_MAX_PRIORITY = 100u + WXTHREAD_MIN_PRIORITY = wxPRIORITY_MIN, + WXTHREAD_DEFAULT_PRIORITY = wxPRIORITY_DEFAULT, + WXTHREAD_MAX_PRIORITY = wxPRIORITY_MAX }; // There are 2 types of mutexes: normal mutexes and recursive ones. The attempt @@ -204,7 +218,7 @@ private: // in order to avoid any overhead under platforms where critical sections are // just mutexes make all wxCriticalSection class functions inline -#if !defined(__WXMSW__) +#if !defined(__WINDOWS__) #define wxCRITSECT_IS_MUTEX 1 #define wxCRITSECT_INLINE WXEXPORT inline @@ -234,13 +248,16 @@ 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(); 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 @@ -248,10 +265,6 @@ private: // // if CRITICAL_SECTION size changes in Windows, you'll get an assert from // thread.cpp and will need to increase the buffer size - // - // 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__ @@ -276,6 +289,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 @@ -447,7 +461,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 +490,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 +530,14 @@ public: // does it! // // will fill the rc pointer with the thread exit code if it's !NULL - wxThreadError Delete(ExitCode *rc = 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. @@ -532,7 +557,8 @@ public: wxThreadError Resume(); // priority - // Sets the priority to "prio": see WXTHREAD_XXX_PRIORITY constants + // Sets the priority to "prio" which must be in 0..100 range (see + // also wxPRIORITY_XXX constants). // // NB: the priority can only be set before the thread is created void SetPriority(unsigned int prio); @@ -575,6 +601,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 +625,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; @@ -747,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 @@ -794,7 +840,7 @@ public: #if wxUSE_THREADS -#if defined(__WXMSW__) || defined(__OS2__) || defined(__EMX__) +#if defined(__WINDOWS__) || defined(__OS2__) || defined(__EMX__) || defined(__DARWIN__) // 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 @@ -806,9 +852,11 @@ public: // wakes up the main thread if it's sleeping inside ::GetMessage() extern void WXDLLIMPEXP_BASE wxWakeUpMainThread(); +#ifndef __DARWIN__ // 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