X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/631f1bfed5d2df0215035207355d838328237578..fbb7dfffb098c0c1a71f15674fba0d3af9609028:/docs/latex/wx/thread.tex diff --git a/docs/latex/wx/thread.tex b/docs/latex/wx/thread.tex index 742473d5da..1559443b69 100644 --- a/docs/latex/wx/thread.tex +++ b/docs/latex/wx/thread.tex @@ -1,45 +1,90 @@ \section{\class{wxThread}}\label{wxthread} -A thread is basically a path of execution through a program. Threads are also +A thread is basically a path of execution through a program. Threads are sometimes called {\it light-weight processes}, but the fundamental difference between threads and processes is that memory spaces of different processes are separated while all threads share the same address space. While it makes it -much easier to share common data between several threads, it also makes much +much easier to share common data between several threads, it also makes it much easier to shoot oneself in the foot, so careful use of synchronization objects such as \helpref{mutexes}{wxmutex} and/or \helpref{critical sections}{wxcriticalsection} is recommended. +There are two types of threads in wxWidgets: {\it detached} and {\it joinable} +ones, just as in the POSIX thread API (but unlike Win32 threads where all threads +are joinable). The difference between the two is that only joinable threads +can return a return code -- this is returned by the Wait() function. Detached +threads (the default type) cannot be waited for. + +You shouldn't hurry to create all the threads joinable, however, because this +has a disadvantage as well: you {\bf must} Wait() for a joinable thread or the +system resources used by it will never be freed, and you also must delete the +corresponding wxThread object yourself. In contrast, detached threads are of the +"fire-and-forget" kind: you only have to start a detached thread and it will +terminate and destroy itself. + +This means, of course, that all detached threads {\bf must} be created on the +heap because the thread will call {\tt delete this;} upon termination. Joinable +threads may be created on the stack although more usually they will be created +on the heap as well. Don't create global thread objects because they allocate +memory in their constructor, which will cause problems for the memory checking +system. Finally, another consequence of the handling of the above is that you +should never delete a detached thread yourself, as this will be done by the +thread itself when it terminates. + \wxheading{Derived from} None. +\wxheading{Include files} + + + \wxheading{See also} \helpref{wxMutex}{wxmutex}, \helpref{wxCondition}{wxcondition}, \helpref{wxCriticalSection}{wxcriticalsection} \latexignore{\rtfignore{\wxheading{Members}}} + \membersection{wxThread::wxThread}\label{wxthreadctor} -\func{}{wxThread}{\void} +\func{}{wxThread}{\param{wxThreadKind }{kind = wxTHREAD\_DETACHED}} -Default constructor: it doesn't create nor starts the thread. +This constructor creates a new detached (default) or joinable C++ thread object. It +does not create or start execution of the real thread -- for this you should +use the \helpref{Create}{wxthreadcreate} and \helpref{Run}{wxthreadrun} methods. -\membersection{wxThread::\destruct{wxThread}} +The possible values for {\it kind} parameters are: + +\twocolwidtha{7cm} +\begin{twocollist}\itemsep=0pt +\twocolitem{{\bf wxTHREAD\_DETACHED}}{Create a detached thread.} +\twocolitem{{\bf wxTHREAD\_JOINABLE}}{Create a joinable thread} +\end{twocollist} + + +\membersection{wxThread::\destruct{wxThread}}\label{wxthreaddtor} \func{}{\destruct{wxThread}}{\void} -wxThread destructor is private, so you can not call it directly - i.e., deleting -wxThread objects is forbidden. Instead, you should use \helpref{Delete}{wxthreaddelete} or -\helpref{Kill}{wxthreadkill} methods. This also means that thread objects should -eb {\bf always} allocated on the heap (i.e. with {\it new}) because the functions -mentioned above will try to reclaim the storage from the heap. +The destructor frees the resources associated with the thread. Notice that you +should never delete a detached thread -- you may only call +\helpref{Delete}{wxthreaddelete} on it or wait until it terminates (and auto +destructs) itself. Because the detached threads delete themselves, they can +only be allocated on the heap. + +Joinable threads should be deleted explicitly. The \helpref{Delete}{wxthreaddelete} and \helpref{Kill}{wxthreadkill} functions +will not delete the C++ thread object. It is also safe to allocate them on +stack. + \membersection{wxThread::Create}\label{wxthreadcreate} -\func{wxThreadError}{Create}{\void} +\func{wxThreadError}{Create}{\param{unsigned int }{stackSize = 0}} -Creates a new thread. The thread object is created in the suspended state, you -should call \helpref{Run}{wxthreadrun} to start running it. +Creates a new thread. The thread object is created in the suspended state, and you +should call \helpref{Run}{wxthreadrun} to start running it. You may optionally +specify the stack size to be allocated to it (Ignored on platforms that don't +support setting it explicitly, eg. Unix). \wxheading{Return value} @@ -52,34 +97,97 @@ One of: \twocolitem{{\bf wxTHREAD\_RUNNING}}{The thread is already running.} \end{twocollist} + \membersection{wxThread::Delete}\label{wxthreaddelete} -\func{\void}{Delete}{\void} +\func{void}{Delete}{\void} + +Calling \helpref{Delete}{wxthreaddelete} is a graceful way to terminate the +thread. It asks the thread to terminate and, if the thread code is well +written, the thread will terminate after the next call to +\helpref{TestDestroy}{wxthreadtestdestroy} which should happen quite soon. + +However, if the thread doesn't call \helpref{TestDestroy}{wxthreadtestdestroy} +often enough (or at all), the function will not return immediately, but wait +until the thread terminates. As it may take a long time, and the message processing +is not stopped during this function execution, message handlers may be +called from inside it! + +Delete() may be called for a thread in any state: running, paused or even not +yet created. Moreover, it must be called if \helpref{Create}{wxthreadcreate} or +\helpref{Run}{wxthreadrun} fail in order to free the memory occupied by the +thread object. However, you should not call Delete() on a detached thread which +already terminated -- doing so will probably result in a crash because the +thread object doesn't exist any more. + +For detached threads Delete() will also delete the C++ thread object, but it +will not do this for joinable ones. + +This function can only be called from another thread context. + + +\membersection{wxThread::Entry}\label{wxthreadentry} + +\func{virtual ExitCode}{Entry}{\void} + +This is the entry point of the thread. This function is pure virtual and must +be implemented by any derived class. The thread execution will start here. -This function should be called to terminate this thread. Unlike \helpref{Kill}{wxthreadkill}, it -gives the target thread the time to terminate gracefully. Because of this, however, this function -may not return immediately and if the thread is "hung" won't return at all. Also, message processing -is not stopped during this function execution, so the message handlers may be called from inside -it. +The returned value is the thread exit code which is only useful for +joinable threads and is the value returned by \helpref{Wait}{wxthreadwait}. -Delete() may be called for thread in any state: running, paused or even not yet created. Moreover, -it must be called if \helpref{Create}{wxthreadcreate} or \helpref{Run}{wxthreadrun} fail to free -the memory occupied by the thread object. +This function is called by wxWidgets itself and should never be called +directly. -\membersection{wxThread::GetID}\label{wxthreadgetid} -\constfunc{unsigned long}{GetID}{\void} +\membersection{wxThread::Exit}\label{wxthreadexit} -Gets the thread identifier: this is a platform dependent number which uniquely identifies the +\func{void}{Exit}{\param{ExitCode }{exitcode = 0}} + +This is a protected function of the wxThread class and thus can only be called +from a derived class. It also can only be called in the context of this +thread, i.e. a thread can only exit from itself, not from another thread. + +This function will terminate the OS thread (i.e. stop the associated path of +execution) and also delete the associated C++ object for detached threads. +\helpref{wxThread::OnExit}{wxthreadonexit} will be called just before exiting. + + +\membersection{wxThread::GetCPUCount}\label{wxthreadgetcpucount} + +\func{static int}{GetCPUCount}{\void} + +Returns the number of system CPUs or -1 if the value is unknown. + +\wxheading{See also} + +\helpref{SetConcurrency}{wxthreadsetconcurrency} + + +\membersection{wxThread::GetCurrentId}\label{wxthreadgetcurrentid} + +\func{static unsigned long}{GetCurrentId}{\void} + +Returns the platform specific thread ID of the current thread as a +long. This can be used to uniquely identify threads, even if they are +not wxThreads. + + +\membersection{wxThread::GetId}\label{wxthreadgetid} + +\constfunc{unsigned long}{GetId}{\void} + +Gets the thread identifier: this is a platform dependent number that uniquely identifies the thread throughout the system during its existence (i.e. the thread identifiers may be reused). + \membersection{wxThread::GetPriority}\label{wxthreadgetpriority} \constfunc{int}{GetPriority}{\void} Gets the priority of the thread, between zero and 100. -The following priorities are already defined: +The following priorities are defined: \twocolwidtha{7cm} \begin{twocollist}\itemsep=0pt @@ -88,29 +196,49 @@ The following priorities are already defined: \twocolitem{{\bf WXTHREAD\_MAX\_PRIORITY}}{100} \end{twocollist} + \membersection{wxThread::IsAlive}\label{wxthreadisalive} \constfunc{bool}{IsAlive}{\void} -Returns TRUE if the thread is alive (i.e. started and not terminating). +Returns \true if the thread is alive (i.e. started and not terminating). + +Note that this function can only safely be used with joinable threads, not +detached ones as the latter delete themselves and so when the real thread is +no longer alive, it is not possible to call this function because +the wxThread object no longer exists. + +\membersection{wxThread::IsDetached}\label{wxthreadisdetached} + +\constfunc{bool}{IsDetached}{\void} + +Returns \true if the thread is of the detached kind, \false if it is a joinable +one. + \membersection{wxThread::IsMain}\label{wxthreadismain} -\constfunc{bool}{IsMain}{\void} +\func{static bool}{IsMain}{\void} + +Returns \true if the calling thread is the main application thread. -Returns TRUE if the calling thread is the main application thread. \membersection{wxThread::IsPaused}\label{wxthreadispaused} \constfunc{bool}{IsPaused}{\void} -Returns TRUE if the thread is paused. +Returns \true if the thread is paused. + \membersection{wxThread::IsRunning}\label{wxthreadisrunning} \constfunc{bool}{IsRunning}{\void} -Returns TRUE if the thread is running. +Returns \true if the thread is running. + +This method may only be safely used for joinable threads, see the remark in +\helpref{IsAlive}{wxthreadisalive}. + \membersection{wxThread::Kill}\label{wxthreadkill} @@ -121,24 +249,61 @@ be used with extreme care (and not used at all whenever possible)!} The resource allocated to the thread will not be freed and the state of the C runtime library may become inconsistent. Use \helpref{Delete()}{wxthreaddelete} instead. +For detached threads Kill() will also delete the associated C++ object. +However this will not happen for joinable threads and this means that you will +still have to delete the wxThread object yourself to avoid memory leaks. +In neither case \helpref{OnExit}{wxthreadonexit} of the dying thread will be +called, so no thread-specific cleanup will be performed. + +This function can only be called from another thread context, i.e. a thread +cannot kill itself. + +It is also an error to call this function for a thread which is not running or +paused (in the latter case, the thread will be resumed first) -- if you do it, +a {\tt wxTHREAD\_NOT\_RUNNING} error will be returned. + + \membersection{wxThread::OnExit}\label{wxthreadonexit} \func{void}{OnExit}{\void} -Called when the thread exits. This function is called in the context of the thread -associated with the wxThread object, not in the context of the main thread. +Called when the thread exits. This function is called in the context of the +thread associated with the wxThread object, not in the context of the main +thread. This function will not be called if the thread was +\helpref{killed}{wxthreadkill}. + +This function should never be called directly. + + +\membersection{wxThread::Pause}\label{wxthreadpause} + +\func{wxThreadError}{Pause}{\void} + +Suspends the thread. Under some implementations (Win32), the thread is +suspended immediately, under others it will only be suspended when it calls +\helpref{TestDestroy}{wxthreadtestdestroy} for the next time (hence, if the +thread doesn't call it at all, it won't be suspended). + +This function can only be called from another thread context. + \membersection{wxThread::Run}\label{wxthreadrun} \func{wxThreadError}{Run}{\void} -Runs the thread. +Starts the thread execution. Should be called after +\helpref{Create}{wxthreadcreate}. + +This function can only be called from another thread context. + \membersection{wxThread::SetPriority}\label{wxthreadsetpriority} \func{void}{SetPriority}{\param{int}{ priority}} -Sets the priority of the thread, between zero and 100. This must be set before the thread is created. +Sets the priority of the thread, between $0$ and $100$. It can only be set +after calling \helpref{Create()}{wxthreadcreate} but before calling +\helpref{Run()}{wxthreadrun}. The following priorities are already defined: @@ -149,29 +314,77 @@ The following priorities are already defined: \twocolitem{{\bf WXTHREAD\_MAX\_PRIORITY}}{100} \end{twocollist} + \membersection{wxThread::Sleep}\label{wxthreadsleep} -\func{\void}{Sleep}{\param{unsigned long }{milliseconds}} +\func{static void}{Sleep}{\param{unsigned long }{milliseconds}} Pauses the thread execution for the given amount of time. This function should be used instead of \helpref{wxSleep}{wxsleep} by all worker -(i.e. all except the main one) threads. +threads (i.e. all except the main one). + + +\membersection{wxThread::Resume}\label{wxthreadresume} + +\func{wxThreadError}{Resume}{\void} + +Resumes a thread suspended by the call to \helpref{Pause}{wxthreadpause}. + +This function can only be called from another thread context. + + +\membersection{wxThread::SetConcurrency}\label{wxthreadsetconcurrency} + +\func{static bool}{SetConcurrency}{\param{size\_t }{level}} + +Sets the thread concurrency level for this process. This is, roughly, the +number of threads that the system tries to schedule to run in parallel. +The value of $0$ for {\it level} may be used to set the default one. + +Returns \true on success or false otherwise (for example, if this function is +not implemented for this platform -- currently everything except Solaris). + + +\membersection{wxThread::TestDestroy}\label{wxthreadtestdestroy} + +\func{virtual bool}{TestDestroy}{\void} + +This function should be called periodically by the thread to ensure that calls +to \helpref{Pause}{wxthreadpause} and \helpref{Delete}{wxthreaddelete} will +work. If it returns \true, the thread should exit as soon as possible. + +Notice that under some platforms (POSIX), implementation of +\helpref{Pause}{wxthreadpause} also relies on this function being called, so +not calling it would prevent both stopping and suspending thread from working. + \membersection{wxThread::This}\label{wxthreadthis} -\func{wxThread *}{This}{\void} +\func{static wxThread *}{This}{\void} Return the thread object for the calling thread. NULL is returned if the calling thread is the main (GUI) thread, but \helpref{IsMain}{wxthreadismain} should be used to test whether the thread is really the main one because NULL may also be returned for the thread -not created with wxThread class. Generally speaking, the return value for such thread +not created with wxThread class. Generally speaking, the return value for such a thread is undefined. + \membersection{wxThread::Yield}\label{wxthreadyield} -\func{\void}{Yield}{\void} +\func{void}{Yield}{\void} Give the rest of the thread time slice to the system allowing the other threads to run. See also \helpref{Sleep()}{wxthreadsleep}. + +\membersection{wxThread::Wait}\label{wxthreadwait} + +\constfunc{ExitCode}{Wait}{\void} + +Waits until the thread terminates and returns its exit code or {\tt (ExitCode)-1} on error. + +You can only Wait() for joinable (not detached) threads. + +This function can only be called from another thread context. +