\membersection{wxThread::wxThread}\label{wxthreadctor}
-\func{}{wxThread}{\void}
+\func{}{wxThread}{\param{wxThreadKind }{kind = wxTHREAD\_DETACHED}}
Constructor creates a new detached (default) or joinable C++ thread object. It
does not create (or starts execution of) the real thread - for this you should
use \helpref{Create}{wxthreadcreate} and \helpref{Run}{wxthreadrun} methods.
+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}}
\func{}{\destruct{wxThread}}{\void}
called from inside it!
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
+created. Moreover, it must be called if \helpref{Create}{wxthreadcreate} or
\helpref{Run}{wxthreadrun} failed for a detached thread to free the memory
occupied by the thread object (it will be done in the destructor for joinable
threads).
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.
+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 is called by wxWindows itself and should never be called
directly.
+\membersection{wxThread::Exit}\label{wxthreadexit}
+
+\func{void}{Exit}{\param{ExitCode }{exitcode = 0}}
+
+This is a protected function of wxThread class and thus can be called only
+from a derived class. It also can be called only 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::GetId}\label{wxthreadgetid}
\constfunc{unsigned long}{GetId}{\void}
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.
+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.
+This function can only be called from another thread context, i.e. a thread
+can not 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,
+{\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.
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{bool}{TestDestroy}{\void}
\constfunc{ExitCode}{Wait}{\void}
-Waits until the thread terminates and returns its exit code or {\tt
-(ExitCode)-1} on error.
+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.
+
projects / wxWidgets.git / blobdiff