/////////////////////////////////////////////////////////////////////////////
// Name: thread.h
-// Purpose: documentation for wxCondition class
+// Purpose: interface of wxCondition
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{thread}
- @seealso
- wxThread, wxMutex
+ @see wxThread, wxMutex
*/
class wxCondition
{
};
+
/**
@class wxCriticalSectionLocker
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxCriticalSection, wxMutexLocker
+ @see wxCriticalSection, wxMutexLocker
*/
class wxCriticalSectionLocker
{
};
+
/**
@class wxThreadHelper
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxThread
+ @see wxThread
*/
class wxThreadHelper
{
};
+
/**
@class wxCriticalSection
@wxheader{thread.h}
A critical section object is used for exactly the same purpose as
- mutexes. The only difference is that under Windows platform
+ mutexes(). The only difference is that under Windows platform
critical sections are only visible inside one process, while mutexes may be
shared between processes, so using critical sections is slightly more
efficient. The terminology is also slightly different: mutex may be locked (or
@library{wxbase}
@category{thread}
- @seealso
- wxThread, wxCondition, wxCriticalSectionLocker
+ @see wxThread, wxCondition, wxCriticalSectionLocker
*/
class wxCriticalSection
{
};
+
/**
@class wxThread
@wxheader{thread.h}
also
makes it much easier to shoot oneself in the foot, so careful use of
synchronization
- objects such as mutexes or @ref overview_wxcriticalsection "critical sections"
- is recommended. In addition, don't create global thread
+ objects such as mutexes() or @ref overview_wxcriticalsection "critical
+ sections" is recommended. In addition, don't create global thread
objects because they allocate memory in their constructor, which will cause
problems for the memory checking system.
@library{wxbase}
@category{thread}
- @seealso
- wxMutex, wxCondition, wxCriticalSection
+ @see wxMutex, wxCondition, wxCriticalSection
*/
class wxThread
{
in fact calling a routine on any running wxThread should be avoided if
possible. Instead, find a way to notify yourself when the thread has ended.
Usually you only need to notify the main thread, in which case you can post
- an event to it via wxPostEvent or
+ an event to it via wxPostEvent() or
wxEvtHandler::AddPendingEvent. In
the case of secondary threads you can call a routine of another class
when the thread is about to complete processing and/or set the value
- of a variable, possibly using mutexes and/or other
+ of a variable, possibly using mutexes() and/or other
synchronization means if necessary.
*/
/**
Pauses the thread execution for the given amount of time.
- This function should be used instead of wxSleep by all worker
+ This function should be used instead of wxSleep() by all worker
threads (i.e. all except the main one).
*/
static void Sleep(unsigned long milliseconds);
and could end your application prematurely. This is due to several reasons,
including the underlying native API and the fact that wxThread does not run a
GUI event loop similar to other APIs as MFC.
- A workaround that works on some wxWidgets ports is calling wxMutexGUIEnter
- before any GUI calls and then calling wxMutexGUILeave afterwords. However,
+ A workaround that works on some wxWidgets ports is calling wxMutexGUIEnter()
+ before any GUI calls and then calling wxMutexGUILeave() afterwords. However,
the recommended way is to simply process the GUI calls in the main thread
- through an event that is posted by either wxPostEvent or
+ through an event that is posted by either wxPostEvent() or
wxEvtHandler::AddPendingEvent. This does
not imply that calls to these classes are thread-safe, however, as most
wxWidgets classes are not thread-safe, including wxString.
};
+
/**
@class wxSemaphore
@wxheader{thread.h}
};
+
/**
@class wxMutexLocker
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxMutex, wxCriticalSectionLocker
+ @see wxMutex, wxCriticalSectionLocker
*/
class wxMutexLocker
{
};
+
/**
@class wxMutex
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxThread, wxCondition, wxMutexLocker, wxCriticalSection
+ @see wxThread, wxCondition, wxMutexLocker, wxCriticalSection
*/
class wxMutex
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
bool wxIsMainThread();
/**
- This macro combines wxCRIT_SECT_DECLARE and
- wxCRIT_SECT_LOCKER: it creates a static critical
+ This macro combines wxCRIT_SECT_DECLARE() and
+ wxCRIT_SECT_LOCKER(): it creates a static critical
section object and also the lock object associated with it. Because of this, it
can be only used inside a function, not at global scope. For example:
This macro declares a critical section object named @a cs if
@c wxUSE_THREADS is 1 and does nothing if it is 0. As it doesn't
include the @c static keyword (unlike
- wxCRIT_SECT_DECLARE), it can be used to declare
+ wxCRIT_SECT_DECLARE()), it can be used to declare
a class or struct member which explains its name.
*/
#define wxCRIT_SECT_DECLARE(cs) /* implementation is private */
projects / wxWidgets.git / blobdiff