X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e570a44b372cf56526c128eab646615fa59520fc..61b98a2dac629cb5dbe1a6834ace6a33ba4eb103:/src/msw/thread.cpp diff --git a/src/msw/thread.cpp b/src/msw/thread.cpp index 1aebef4756..58bb6013ba 100644 --- a/src/msw/thread.cpp +++ b/src/msw/thread.cpp @@ -26,7 +26,6 @@ #include "wx/thread.h" #ifndef WX_PRECOMP - #include "wx/msw/missing.h" #include "wx/intl.h" #include "wx/app.h" #include "wx/module.h" @@ -36,6 +35,7 @@ #include "wx/scopeguard.h" #include "wx/msw/private.h" +#include "wx/msw/missing.h" #include "wx/msw/seh.h" #include "wx/except.h" @@ -75,7 +75,8 @@ // this is where _beginthreadex() is declared #include - // the return type of the thread function entry point + // the return type of the thread function entry point: notice that this + // type can't hold a pointer under Win64 typedef unsigned THREAD_RETVAL; // the calling convention of the thread function entry point @@ -86,6 +87,8 @@ #define THREAD_CALLCONV WINAPI #endif +static const THREAD_RETVAL THREAD_ERROR_EXIT = (THREAD_RETVAL)-1; + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -110,7 +113,7 @@ static DWORD gs_tlsThisThread = 0xFFFFFFFF; // id of the main thread - the one which can call GUI functions without first // calling wxMutexGuiEnter() -static DWORD gs_idMainThread = 0; +wxThreadIdType wxThread::ms_idMainThread = 0; // if it's false, some secondary thread is holding the GUI lock static bool gs_bGuiOwnedByMainThread = true; @@ -142,7 +145,7 @@ static bool gs_waitingForThread = false; // wxCriticalSection // ---------------------------------------------------------------------------- -wxCriticalSection::wxCriticalSection() +wxCriticalSection::wxCriticalSection( wxCriticalSectionType WXUNUSED(critSecType) ) { wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer), wxCriticalSectionBufferTooSmall ); @@ -178,7 +181,8 @@ public: bool IsOk() const { return m_mutex != NULL; } wxMutexError Lock() { return LockTimeout(INFINITE); } - wxMutexError TryLock() { return LockTimeout(0); } + wxMutexError Lock(unsigned long ms) { return LockTimeout(ms); } + wxMutexError TryLock(); wxMutexError Unlock(); private: @@ -186,24 +190,31 @@ private: HANDLE m_mutex; - DECLARE_NO_COPY_CLASS(wxMutexInternal) + unsigned long m_owningThread; + wxMutexType m_type; + + wxDECLARE_NO_COPY_CLASS(wxMutexInternal); }; // all mutexes are recursive under Win32 so we don't use mutexType -wxMutexInternal::wxMutexInternal(wxMutexType WXUNUSED(mutexType)) +wxMutexInternal::wxMutexInternal(wxMutexType mutexType) { // create a nameless (hence intra process and always private) mutex m_mutex = ::CreateMutex ( NULL, // default secutiry attributes - false, // not initially locked + FALSE, // not initially locked NULL // no name ); + m_type = mutexType; + m_owningThread = 0; + if ( !m_mutex ) { - wxLogLastError(_T("CreateMutex()")); + wxLogLastError(wxT("CreateMutex()")); } + } wxMutexInternal::~wxMutexInternal() @@ -212,51 +223,73 @@ wxMutexInternal::~wxMutexInternal() { if ( !::CloseHandle(m_mutex) ) { - wxLogLastError(_T("CloseHandle(mutex)")); + wxLogLastError(wxT("CloseHandle(mutex)")); } } } +wxMutexError wxMutexInternal::TryLock() +{ + const wxMutexError rc = LockTimeout(0); + + // we have a special return code for timeout in this case + return rc == wxMUTEX_TIMEOUT ? wxMUTEX_BUSY : rc; +} + wxMutexError wxMutexInternal::LockTimeout(DWORD milliseconds) { - DWORD rc = ::WaitForSingleObject(m_mutex, milliseconds); - if ( rc == WAIT_ABANDONED ) + if (m_type == wxMUTEX_DEFAULT) { - // the previous caller died without releasing the mutex, but now we can - // really lock it - wxLogDebug(_T("WaitForSingleObject() returned WAIT_ABANDONED")); - - // use 0 timeout, normally we should always get it - rc = ::WaitForSingleObject(m_mutex, 0); + // Don't allow recursive + if (m_owningThread != 0) + { + if (m_owningThread == wxThread::GetCurrentId()) + return wxMUTEX_DEAD_LOCK; + } } + DWORD rc = ::WaitForSingleObject(m_mutex, milliseconds); switch ( rc ) { + case WAIT_ABANDONED: + // the previous caller died without releasing the mutex, so even + // though we did get it, log a message about this + wxLogDebug(wxT("WaitForSingleObject() returned WAIT_ABANDONED")); + // fall through + case WAIT_OBJECT_0: // ok break; case WAIT_TIMEOUT: - return wxMUTEX_BUSY; + return wxMUTEX_TIMEOUT; - case WAIT_ABANDONED: // checked for above default: wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock")); // fall through case WAIT_FAILED: - wxLogLastError(_T("WaitForSingleObject(mutex)")); + wxLogLastError(wxT("WaitForSingleObject(mutex)")); return wxMUTEX_MISC_ERROR; } + if (m_type == wxMUTEX_DEFAULT) + { + // required for checking recursiveness + m_owningThread = wxThread::GetCurrentId(); + } + return wxMUTEX_NO_ERROR; } wxMutexError wxMutexInternal::Unlock() { + // required for checking recursiveness + m_owningThread = 0; + if ( !::ReleaseMutex(m_mutex) ) { - wxLogLastError(_T("ReleaseMutex()")); + wxLogLastError(wxT("ReleaseMutex()")); return wxMUTEX_MISC_ERROR; } @@ -295,7 +328,7 @@ public: private: HANDLE m_semaphore; - DECLARE_NO_COPY_CLASS(wxSemaphoreInternal) + wxDECLARE_NO_COPY_CLASS(wxSemaphoreInternal); }; wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) @@ -317,7 +350,7 @@ wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) #endif if ( !m_semaphore ) { - wxLogLastError(_T("CreateSemaphore()")); + wxLogLastError(wxT("CreateSemaphore()")); } } @@ -327,7 +360,7 @@ wxSemaphoreInternal::~wxSemaphoreInternal() { if ( !::CloseHandle(m_semaphore) ) { - wxLogLastError(_T("CloseHandle(semaphore)")); + wxLogLastError(wxT("CloseHandle(semaphore)")); } } } @@ -345,7 +378,7 @@ wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds) return wxSEMA_TIMEOUT; default: - wxLogLastError(_T("WaitForSingleObject(semaphore)")); + wxLogLastError(wxT("WaitForSingleObject(semaphore)")); } return wxSEMA_MISC_ERROR; @@ -362,7 +395,7 @@ wxSemaError wxSemaphoreInternal::Post() } else { - wxLogLastError(_T("ReleaseSemaphore")); + wxLogLastError(wxT("ReleaseSemaphore")); return wxSEMA_MISC_ERROR; } } @@ -417,6 +450,7 @@ public: // (politely, this is not Kill()!) to do it wxThreadError WaitForTerminate(wxCriticalSection& cs, wxThread::ExitCode *pRc, + wxThreadWait waitMode, wxThread *threadToDelete = NULL); // kill the thread unconditionally @@ -474,7 +508,7 @@ private: // reaches 0 we kill the owning wxThread -- and die ourselves with it LONG m_nRef; - DECLARE_NO_COPY_CLASS(wxThreadInternal) + wxDECLARE_NO_COPY_CLASS(wxThreadInternal); }; // small class which keeps a thread alive during its lifetime @@ -505,19 +539,19 @@ THREAD_RETVAL wxThreadInternal::DoThreadStart(wxThread *thread) { wxON_BLOCK_EXIT1(DoThreadOnExit, thread); - THREAD_RETVAL rc = (THREAD_RETVAL)-1; + THREAD_RETVAL rc = THREAD_ERROR_EXIT; wxTRY { // store the thread object in the TLS if ( !::TlsSetValue(gs_tlsThisThread, thread) ) { - wxLogSysError(_("Can not start thread: error writing TLS.")); + wxLogSysError(_("Cannot start thread: error writing TLS.")); - return (THREAD_RETVAL)-1; + return THREAD_ERROR_EXIT; } - rc = (THREAD_RETVAL)thread->Entry(); + rc = wxPtrToUInt(thread->Entry()); } wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) @@ -527,7 +561,7 @@ THREAD_RETVAL wxThreadInternal::DoThreadStart(wxThread *thread) /* static */ THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param) { - THREAD_RETVAL rc = (THREAD_RETVAL)-1; + THREAD_RETVAL rc = THREAD_ERROR_EXIT; wxThread * const thread = (wxThread *)param; @@ -546,7 +580,7 @@ THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param) else rc = DoThreadStart(thread); } - wxSEH_HANDLE((THREAD_RETVAL)-1) + wxSEH_HANDLE(THREAD_ERROR_EXIT) // save IsDetached because thread object can be deleted by joinable @@ -601,7 +635,7 @@ void wxThreadInternal::SetPriority(unsigned int priority) bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize) { wxASSERT_MSG( m_state == STATE_NEW && !m_hThread, - _T("Create()ing thread twice?") ); + wxT("Create()ing thread twice?") ); // for compilers which have it, we should use C RTL function for thread // creation instead of Win32 API one because otherwise we will have memory @@ -653,7 +687,9 @@ bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize) wxThreadError wxThreadInternal::Kill() { - if ( !::TerminateThread(m_hThread, (DWORD)-1) ) + m_thread->OnKill(); + + if ( !::TerminateThread(m_hThread, THREAD_ERROR_EXIT) ) { wxLogSysError(_("Couldn't terminate thread")); @@ -668,6 +704,7 @@ wxThreadError wxThreadInternal::Kill() wxThreadError wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, wxThread::ExitCode *pRc, + wxThreadWait waitMode, wxThread *threadToDelete) { // prevent the thread C++ object from disappearing as long as we are using @@ -679,7 +716,7 @@ wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, // from Wait()) or ask it to terminate (when called from Delete()) bool shouldDelete = threadToDelete != NULL; - wxThread::ExitCode rc = 0; + DWORD rc = 0; // we might need to resume the thread if it's currently stopped bool shouldResume = false; @@ -726,6 +763,8 @@ wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, Cancel(); } + if ( threadToDelete ) + threadToDelete->OnDelete(); // now wait for thread to finish if ( wxThread::IsMain() ) @@ -752,13 +791,10 @@ wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, } } -#if !defined(QS_ALLPOSTMESSAGE) -#define QS_ALLPOSTMESSAGE 0 -#endif wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; if ( traits ) { - result = traits->WaitForThread(m_hThread); + result = traits->WaitForThread(m_hThread, waitMode); } else // can't wait for the thread { @@ -770,7 +806,7 @@ wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, { case 0xFFFFFFFF: // error - wxLogSysError(_("Can not wait for thread termination")); + wxLogSysError(_("Cannot wait for thread termination")); Kill(); return wxTHREAD_KILLED; @@ -815,16 +851,16 @@ wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, // terminated if the "if" above hadn't been taken for ( ;; ) { - if ( !::GetExitCodeThread(m_hThread, (LPDWORD)&rc) ) + if ( !::GetExitCodeThread(m_hThread, &rc) ) { wxLogLastError(wxT("GetExitCodeThread")); - rc = (wxThread::ExitCode)-1; + rc = THREAD_ERROR_EXIT; break; } - if ( (DWORD)rc != STILL_ACTIVE ) + if ( rc != STILL_ACTIVE ) break; // give the other thread some time to terminate, otherwise we may be @@ -833,14 +869,13 @@ wxThreadInternal::WaitForTerminate(wxCriticalSection& cs, } if ( pRc ) - *pRc = rc; + *pRc = wxUIntToPtr(rc); // we don't need the thread handle any more in any case Free(); - return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR - : wxTHREAD_NO_ERROR; + return rc == THREAD_ERROR_EXIT ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR; } bool wxThreadInternal::Suspend() @@ -848,7 +883,7 @@ bool wxThreadInternal::Suspend() DWORD nSuspendCount = ::SuspendThread(m_hThread); if ( nSuspendCount == (DWORD)-1 ) { - wxLogSysError(_("Can not suspend thread %x"), m_hThread); + wxLogSysError(_("Cannot suspend thread %x"), m_hThread); return false; } @@ -863,7 +898,7 @@ bool wxThreadInternal::Resume() DWORD nSuspendCount = ::ResumeThread(m_hThread); if ( nSuspendCount == (DWORD)-1 ) { - wxLogSysError(_("Can not resume thread %x"), m_hThread); + wxLogSysError(_("Cannot resume thread %x"), m_hThread); return false; } @@ -897,11 +932,6 @@ wxThread *wxThread::This() return thread; } -bool wxThread::IsMain() -{ - return ::GetCurrentThreadId() == gs_idMainThread || gs_idMainThread == 0; -} - void wxThread::Yield() { // 0 argument to Sleep() is special and means to just give away the rest of @@ -909,11 +939,6 @@ void wxThread::Yield() ::Sleep(0); } -void wxThread::Sleep(unsigned long milliseconds) -{ - ::Sleep(milliseconds); -} - int wxThread::GetCPUCount() { SYSTEM_INFO si; @@ -932,7 +957,7 @@ bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level)) #ifdef __WXWINCE__ return false; #else - wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") ); + wxASSERT_MSG( IsMain(), wxT("should only be called from the main thread") ); // ok only for the default one if ( level == 0 ) @@ -943,7 +968,7 @@ bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level)) DWORD_PTR dwProcMask, dwSysMask; if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 ) { - wxLogLastError(_T("GetProcessAffinityMask")); + wxLogLastError(wxT("GetProcessAffinityMask")); return false; } @@ -982,7 +1007,7 @@ bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level)) // could we set all bits? if ( level != 0 ) { - wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level); + wxLogDebug(wxT("bad level %u in wxThread::SetConcurrency()"), level); return false; } @@ -990,14 +1015,14 @@ bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level)) // set it: we can't link to SetProcessAffinityMask() because it doesn't // exist in Win9x, use RT binding instead - typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD); + typedef BOOL (WINAPI *SETPROCESSAFFINITYMASK)(HANDLE, DWORD_PTR); // can use static var because we're always in the main thread here static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL; if ( !pfnSetProcessAffinityMask ) { - HMODULE hModKernel = ::LoadLibrary(_T("kernel32")); + HMODULE hModKernel = ::LoadLibrary(wxT("kernel32")); if ( hModKernel ) { pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK) @@ -1006,7 +1031,7 @@ bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level)) // we've discovered a MT version of Win9x! wxASSERT_MSG( pfnSetProcessAffinityMask, - _T("this system has several CPUs but no SetProcessAffinityMask function?") ); + wxT("this system has several CPUs but no SetProcessAffinityMask function?") ); } if ( !pfnSetProcessAffinityMask ) @@ -1017,7 +1042,7 @@ bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level)) if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 ) { - wxLogLastError(_T("SetProcessAffinityMask")); + wxLogLastError(wxT("SetProcessAffinityMask")); return false; } @@ -1058,11 +1083,8 @@ wxThreadError wxThread::Run() { wxCriticalSectionLocker lock(m_critsect); - if ( m_internal->GetState() != STATE_NEW ) - { - // actually, it may be almost any state at all, not only STATE_RUNNING - return wxTHREAD_RUNNING; - } + wxCHECK_MSG( m_internal->GetState() == STATE_NEW, wxTHREAD_RUNNING, + wxT("thread may only be started once after Create()") ); // the thread has just been created and is still suspended - let it run return Resume(); @@ -1088,23 +1110,23 @@ wxThreadError wxThread::Resume() // stopping thread // --------------- -wxThread::ExitCode wxThread::Wait() +wxThread::ExitCode wxThread::Wait(wxThreadWait waitMode) { + ExitCode rc = wxUIntToPtr(THREAD_ERROR_EXIT); + // although under Windows we can wait for any thread, it's an error to // wait for a detached one in wxWin API - wxCHECK_MSG( !IsDetached(), (ExitCode)-1, - _T("wxThread::Wait(): can't wait for detached thread") ); - - ExitCode rc = (ExitCode)-1; + wxCHECK_MSG( !IsDetached(), rc, + wxT("wxThread::Wait(): can't wait for detached thread") ); - (void)m_internal->WaitForTerminate(m_critsect, &rc); + (void)m_internal->WaitForTerminate(m_critsect, &rc, waitMode); return rc; } -wxThreadError wxThread::Delete(ExitCode *pRc) +wxThreadError wxThread::Delete(ExitCode *pRc, wxThreadWait waitMode) { - return m_internal->WaitForTerminate(m_critsect, pRc, this); + return m_internal->WaitForTerminate(m_critsect, pRc, waitMode, this); } wxThreadError wxThread::Kill() @@ -1144,7 +1166,7 @@ void wxThread::Exit(ExitCode status) } #ifdef wxUSE_BEGIN_THREAD - _endthreadex((unsigned)status); + _endthreadex(wxPtrToUInt(status)); #else // !VC++ ::ExitThread((DWORD)status); #endif // VC++/!VC++ @@ -1164,28 +1186,28 @@ void wxThread::SetPriority(unsigned int prio) unsigned int wxThread::GetPriority() const { - wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast + wxCriticalSectionLocker lock(const_cast(m_critsect)); return m_internal->GetPriority(); } unsigned long wxThread::GetId() const { - wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast + wxCriticalSectionLocker lock(const_cast(m_critsect)); return (unsigned long)m_internal->GetId(); } bool wxThread::IsRunning() const { - wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast + wxCriticalSectionLocker lock(const_cast(m_critsect)); return m_internal->GetState() == STATE_RUNNING; } bool wxThread::IsAlive() const { - wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast + wxCriticalSectionLocker lock(const_cast(m_critsect)); return (m_internal->GetState() == STATE_RUNNING) || (m_internal->GetState() == STATE_PAUSED); @@ -1193,14 +1215,14 @@ bool wxThread::IsAlive() const bool wxThread::IsPaused() const { - wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast + wxCriticalSectionLocker lock(const_cast(m_critsect)); return m_internal->GetState() == STATE_PAUSED; } bool wxThread::TestDestroy() { - wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast + wxCriticalSectionLocker lock(const_cast(m_critsect)); return m_internal->GetState() == STATE_CANCELED; } @@ -1242,7 +1264,7 @@ bool wxThreadModule::OnInit() ::TlsFree(gs_tlsThisThread); gs_tlsThisThread = 0xFFFFFFFF; - wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage")); + wxLogSysError(_("Thread module initialization failed: cannot store value in thread local storage")); return false; } @@ -1254,8 +1276,7 @@ bool wxThreadModule::OnInit() gs_critsectThreadDelete = new wxCriticalSection; - // no error return for GetCurrentThreadId() - gs_idMainThread = ::GetCurrentThreadId(); + wxThread::ms_idMainThread = wxThread::GetCurrentId(); return true; } @@ -1267,18 +1288,15 @@ void wxThreadModule::OnExit() wxLogLastError(wxT("TlsFree failed.")); } - delete gs_critsectThreadDelete; - gs_critsectThreadDelete = NULL; + wxDELETE(gs_critsectThreadDelete); if ( gs_critsectGui ) { gs_critsectGui->Leave(); - delete gs_critsectGui; - gs_critsectGui = NULL; + wxDELETE(gs_critsectGui); } - delete gs_critsectWaitingForGui; - gs_critsectWaitingForGui = NULL; + wxDELETE(gs_critsectWaitingForGui); } // ---------------------------------------------------------------------------- @@ -1286,7 +1304,7 @@ void wxThreadModule::OnExit() // not a mutex, so the names are a bit confusing // ---------------------------------------------------------------------------- -void WXDLLIMPEXP_BASE wxMutexGuiEnter() +void wxMutexGuiEnterImpl() { // this would dead lock everything... wxASSERT_MSG( !wxThread::IsMain(), @@ -1308,7 +1326,7 @@ void WXDLLIMPEXP_BASE wxMutexGuiEnter() gs_critsectGui->Enter(); } -void WXDLLIMPEXP_BASE wxMutexGuiLeave() +void wxMutexGuiLeaveImpl() { wxCriticalSectionLocker enter(*gs_critsectWaitingForGui); @@ -1369,7 +1387,7 @@ bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread() void WXDLLIMPEXP_BASE wxWakeUpMainThread() { // sending any message would do - hopefully WM_NULL is harmless enough - if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) ) + if ( !::PostThreadMessage(wxThread::GetMainId(), WM_NULL, 0, 0) ) { // should never happen wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));