docs/latex/wx/thread.tex

   1 \section{\class{wxThread}}\label{wxthread}
   2
   3 A thread is basically a path of execution through a program. Threads are
   4 sometimes called {\it light-weight processes}, but the fundamental difference
   5 between threads and processes is that memory spaces of different processes are
   6 separated while all threads share the same address space. While it makes it
   7 much easier to share common data between several threads, it also makes it much
   8 easier to shoot oneself in the foot, so careful use of synchronization objects
   9 such as \helpref{mutexes}{wxmutex} and/or \helpref{critical sections}{wxcriticalsection} is recommended.
  10
  11 There are two types of threads in wxWidgets: {\it detached} and {\it joinable}
  12 ones, just as in the POSIX thread API (but unlike Win32 threads where all threads
  13 are joinable). The difference between the two is that only joinable threads
  14 can return a return code -- this is returned by the Wait() function. Detached
  15 threads (the default type) cannot be waited for.
  16
  17 You shouldn't hurry to create all the threads joinable, however, because this
  18 has a disadvantage as well: you {\bf must} Wait() for a joinable thread or the
  19 system resources used by it will never be freed, and you also must delete the
  20 corresponding wxThread object yourself. In contrast, detached threads are of the
  21 "fire-and-forget" kind: you only have to start a detached thread and it will
  22 terminate and destroy itself.
  23
  24 This means, of course, that all detached threads {\bf must} be created on the
  25 heap because the thread will call {\tt delete this;} upon termination. Joinable
  26 threads may be created on the stack although more usually they will be created
  27 on the heap as well. Don't create global thread objects because they allocate
  28 memory in their constructor, which will cause problems for the memory checking
  29 system. Finally, another consequence of the handling of the above is that you
  30 should never delete a detached thread yourself, as this will be done by the
  31 thread itself when it terminates.
  32
  33 \wxheading{Derived from}
  34
  35 None.
  36
  37 \wxheading{Include files}
  38
  39 <wx/thread.h>
  40
  41 \wxheading{See also}
  42
  43 \helpref{wxMutex}{wxmutex}, \helpref{wxCondition}{wxcondition}, \helpref{wxCriticalSection}{wxcriticalsection}
  44
  45 \latexignore{\rtfignore{\wxheading{Members}}}
  46
  47
  48 \membersection{wxThread::wxThread}\label{wxthreadctor}
  49
  50 \func{}{wxThread}{\param{wxThreadKind }{kind = wxTHREAD\_DETACHED}}
  51
  52 This constructor creates a new detached (default) or joinable C++ thread object. It
  53 does not create or start execution of the real thread -- for this you should
  54 use the \helpref{Create}{wxthreadcreate} and \helpref{Run}{wxthreadrun} methods.
  55
  56 The possible values for {\it kind} parameters are:
  57
  58 \twocolwidtha{7cm}
  59 \begin{twocollist}\itemsep=0pt
  60 \twocolitem{{\bf wxTHREAD\_DETACHED}}{Create a detached thread.}
  61 \twocolitem{{\bf wxTHREAD\_JOINABLE}}{Create a joinable thread}
  62 \end{twocollist}
  63
  64
  65 \membersection{wxThread::\destruct{wxThread}}\label{wxthreaddtor}
  66
  67 \func{}{\destruct{wxThread}}{\void}
  68
  69 The destructor frees the resources associated with the thread. Notice that you
  70 should never delete a detached thread -- you may only call
  71 \helpref{Delete}{wxthreaddelete} on it or wait until it terminates (and auto
  72 destructs) itself. Because the detached threads delete themselves, they can
  73 only be allocated on the heap.
  74
  75 Joinable threads should be deleted explicitly. The \helpref{Delete}{wxthreaddelete} and \helpref{Kill}{wxthreadkill} functions
  76 will not delete the C++ thread object. It is also safe to allocate them on
  77 stack.
  78
  79
  80 \membersection{wxThread::Create}\label{wxthreadcreate}
  81
  82 \func{wxThreadError}{Create}{\param{unsigned int }{stackSize = 0}}
  83
  84 Creates a new thread. The thread object is created in the suspended state, and you
  85 should call \helpref{Run}{wxthreadrun} to start running it.  You may optionally
  86 specify the stack size to be allocated to it (Ignored on platforms that don't
  87 support setting it explicitly, eg. Unix).
  88
  89 \wxheading{Return value}
  90
  91 One of:
  92
  93 \twocolwidtha{7cm}
  94 \begin{twocollist}\itemsep=0pt
  95 \twocolitem{{\bf wxTHREAD\_NO\_ERROR}}{There was no error.}
  96 \twocolitem{{\bf wxTHREAD\_NO\_RESOURCE}}{There were insufficient resources to create a new thread.}
  97 \twocolitem{{\bf wxTHREAD\_RUNNING}}{The thread is already running.}
  98 \end{twocollist}
  99
 100
 101 \membersection{wxThread::Delete}\label{wxthreaddelete}
 102
 103 \func{void}{Delete}{\void}
 104
 105 Calling \helpref{Delete}{wxthreaddelete} is a graceful way to terminate the
 106 thread. It asks the thread to terminate and, if the thread code is well
 107 written, the thread will terminate after the next call to
 108 \helpref{TestDestroy}{wxthreadtestdestroy} which should happen quite soon.
 109
 110 However, if the thread doesn't call \helpref{TestDestroy}{wxthreadtestdestroy}
 111 often enough (or at all), the function will not return immediately, but wait
 112 until the thread terminates. As it may take a long time, and the message processing
 113 is not stopped during this function execution, message handlers may be
 114 called from inside it!
 115
 116 Delete() may be called for a thread in any state: running, paused or even not
 117 yet created. Moreover, it must be called if \helpref{Create}{wxthreadcreate} or
 118 \helpref{Run}{wxthreadrun} fail in order to free the memory occupied by the
 119 thread object. However, you should not call Delete() on a detached thread which
 120 already terminated -- doing so will probably result in a crash because the
 121 thread object doesn't exist any more.
 122
 123 For detached threads Delete() will also delete the C++ thread object, but it
 124 will not do this for joinable ones.
 125
 126 This function can only be called from another thread context.
 127
 128
 129 \membersection{wxThread::Entry}\label{wxthreadentry}
 130
 131 \func{virtual ExitCode}{Entry}{\void}
 132
 133 This is the entry point of the thread. This function is pure virtual and must
 134 be implemented by any derived class. The thread execution will start here.
 135
 136 The returned value is the thread exit code which is only useful for
 137 joinable threads and is the value returned by \helpref{Wait}{wxthreadwait}.
 138
 139 This function is called by wxWidgets itself and should never be called
 140 directly.
 141
 142
 143 \membersection{wxThread::Exit}\label{wxthreadexit}
 144
 145 \func{void}{Exit}{\param{ExitCode }{exitcode = 0}}
 146
 147 This is a protected function of the wxThread class and thus can only be called
 148 from a derived class. It also can only be called in the context of this
 149 thread, i.e. a thread can only exit from itself, not from another thread.
 150
 151 This function will terminate the OS thread (i.e. stop the associated path of
 152 execution) and also delete the associated C++ object for detached threads.
 153 \helpref{wxThread::OnExit}{wxthreadonexit} will be called just before exiting.
 154
 155
 156 \membersection{wxThread::GetCPUCount}\label{wxthreadgetcpucount}
 157
 158 \func{static int}{GetCPUCount}{\void}
 159
 160 Returns the number of system CPUs or -1 if the value is unknown.
 161
 162 \wxheading{See also}
 163
 164 \helpref{SetConcurrency}{wxthreadsetconcurrency}
 165
 166
 167 \membersection{wxThread::GetCurrentId}\label{wxthreadgetcurrentid}
 168
 169 \func{static unsigned long}{GetCurrentId}{\void}
 170
 171 Returns the platform specific thread ID of the current thread as a
 172 long.  This can be used to uniquely identify threads, even if they are
 173 not wxThreads.
 174
 175
 176 \membersection{wxThread::GetId}\label{wxthreadgetid}
 177
 178 \constfunc{unsigned long}{GetId}{\void}
 179
 180 Gets the thread identifier: this is a platform dependent number that uniquely identifies the
 181 thread throughout the system during its existence (i.e. the thread identifiers may be reused).
 182
 183
 184 \membersection{wxThread::GetPriority}\label{wxthreadgetpriority}
 185
 186 \constfunc{int}{GetPriority}{\void}
 187
 188 Gets the priority of the thread, between zero and 100.
 189
 190 The following priorities are defined:
 191
 192 \twocolwidtha{7cm}
 193 \begin{twocollist}\itemsep=0pt
 194 \twocolitem{{\bf WXTHREAD\_MIN\_PRIORITY}}{0}
 195 \twocolitem{{\bf WXTHREAD\_DEFAULT\_PRIORITY}}{50}
 196 \twocolitem{{\bf WXTHREAD\_MAX\_PRIORITY}}{100}
 197 \end{twocollist}
 198
 199
 200 \membersection{wxThread::IsAlive}\label{wxthreadisalive}
 201
 202 \constfunc{bool}{IsAlive}{\void}
 203
 204 Returns \true if the thread is alive (i.e. started and not terminating).
 205
 206 Note that this function can only be saely used with joinable threads, not
 207 detached ones as the latter delete themselves and so when the real thread is
 208 not alive any longer it is not possible to call this function neither because
 209 the wxThread object doesn't exist any more as well.
 210
 211
 212 \membersection{wxThread::IsDetached}\label{wxthreadisdetached}
 213
 214 \constfunc{bool}{IsDetached}{\void}
 215
 216 Returns \true if the thread is of the detached kind, \false if it is a joinable
 217 one.
 218
 219
 220 \membersection{wxThread::IsMain}\label{wxthreadismain}
 221
 222 \func{static bool}{IsMain}{\void}
 223
 224 Returns \true if the calling thread is the main application thread.
 225
 226
 227 \membersection{wxThread::IsPaused}\label{wxthreadispaused}
 228
 229 \constfunc{bool}{IsPaused}{\void}
 230
 231 Returns \true if the thread is paused.
 232
 233
 234 \membersection{wxThread::IsRunning}\label{wxthreadisrunning}
 235
 236 \constfunc{bool}{IsRunning}{\void}
 237
 238 Returns \true if the thread is running.
 239
 240 This method may only be safely used for joinable threads, see the remark in
 241 \helpref{IsAlive}{wxthreadisalive}.
 242
 243
 244 \membersection{wxThread::Kill}\label{wxthreadkill}
 245
 246 \func{wxThreadError}{Kill}{\void}
 247
 248 Immediately terminates the target thread. {\bf This function is dangerous and should
 249 be used with extreme care (and not used at all whenever possible)!} The resources
 250 allocated to the thread will not be freed and the state of the C runtime library
 251 may become inconsistent. Use \helpref{Delete()}{wxthreaddelete} instead.
 252
 253 For detached threads Kill() will also delete the associated C++ object.
 254 However this will not happen for joinable threads and this means that you will
 255 still have to delete the wxThread object yourself to avoid memory leaks.
 256 In neither case \helpref{OnExit}{wxthreadonexit} of the dying thread will be
 257 called, so no thread-specific cleanup will be performed.
 258
 259 This function can only be called from another thread context, i.e. a thread
 260 cannot kill itself.
 261
 262 It is also an error to call this function for a thread which is not running or
 263 paused (in the latter case, the thread will be resumed first) -- if you do it,
 264 a {\tt wxTHREAD\_NOT\_RUNNING} error will be returned.
 265
 266
 267 \membersection{wxThread::OnExit}\label{wxthreadonexit}
 268
 269 \func{void}{OnExit}{\void}
 270
 271 Called when the thread exits. This function is called in the context of the
 272 thread associated with the wxThread object, not in the context of the main
 273 thread. This function will not be called if the thread was
 274 \helpref{killed}{wxthreadkill}.
 275
 276 This function should never be called directly.
 277
 278
 279 \membersection{wxThread::Pause}\label{wxthreadpause}
 280
 281 \func{wxThreadError}{Pause}{\void}
 282
 283 Suspends the thread. Under some implementations (Win32), the thread is
 284 suspended immediately, under others it will only be suspended when it calls
 285 \helpref{TestDestroy}{wxthreadtestdestroy} for the next time (hence, if the
 286 thread doesn't call it at all, it won't be suspended).
 287
 288 This function can only be called from another thread context.
 289
 290
 291 \membersection{wxThread::Run}\label{wxthreadrun}
 292
 293 \func{wxThreadError}{Run}{\void}
 294
 295 Starts the thread execution. Should be called after
 296 \helpref{Create}{wxthreadcreate}.
 297
 298 This function can only be called from another thread context.
 299
 300
 301 \membersection{wxThread::SetPriority}\label{wxthreadsetpriority}
 302
 303 \func{void}{SetPriority}{\param{int}{ priority}}
 304
 305 Sets the priority of the thread, between $0$ and $100$. It can only be set
 306 after calling \helpref{Create()}{wxthreadcreate} but before calling
 307 \helpref{Run()}{wxthreadrun}.
 308
 309 The following priorities are already defined:
 310
 311 \twocolwidtha{7cm}
 312 \begin{twocollist}\itemsep=0pt
 313 \twocolitem{{\bf WXTHREAD\_MIN\_PRIORITY}}{0}
 314 \twocolitem{{\bf WXTHREAD\_DEFAULT\_PRIORITY}}{50}
 315 \twocolitem{{\bf WXTHREAD\_MAX\_PRIORITY}}{100}
 316 \end{twocollist}
 317
 318
 319 \membersection{wxThread::Sleep}\label{wxthreadsleep}
 320
 321 \func{static void}{Sleep}{\param{unsigned long }{milliseconds}}
 322
 323 Pauses the thread execution for the given amount of time.
 324
 325 This function should be used instead of \helpref{wxSleep}{wxsleep} by all worker
 326 threads (i.e. all except the main one).
 327
 328
 329 \membersection{wxThread::Resume}\label{wxthreadresume}
 330
 331 \func{wxThreadError}{Resume}{\void}
 332
 333 Resumes a thread suspended by the call to \helpref{Pause}{wxthreadpause}.
 334
 335 This function can only be called from another thread context.
 336
 337
 338 \membersection{wxThread::SetConcurrency}\label{wxthreadsetconcurrency}
 339
 340 \func{static bool}{SetConcurrency}{\param{size\_t }{level}}
 341
 342 Sets the thread concurrency level for this process. This is, roughly, the
 343 number of threads that the system tries to schedule to run in parallel.
 344 The value of $0$ for {\it level} may be used to set the default one.
 345
 346 Returns \true on success or false otherwise (for example, if this function is
 347 not implemented for this platform -- currently everything except Solaris).
 348
 349
 350 \membersection{wxThread::TestDestroy}\label{wxthreadtestdestroy}
 351
 352 \func{virtual bool}{TestDestroy}{\void}
 353
 354 This function should be called periodically by the thread to ensure that calls
 355 to \helpref{Pause}{wxthreadpause} and \helpref{Delete}{wxthreaddelete} will
 356 work. If it returns \true, the thread should exit as soon as possible.
 357
 358 Notice that under some platforms (POSIX), implementation of
 359 \helpref{Pause}{wxthreadpause} also relies on this function being called, so
 360 not calling it would prevent both stopping and suspending thread from working.
 361
 362
 363 \membersection{wxThread::This}\label{wxthreadthis}
 364
 365 \func{static wxThread *}{This}{\void}
 366
 367 Return the thread object for the calling thread. NULL is returned if the calling thread
 368 is the main (GUI) thread, but \helpref{IsMain}{wxthreadismain} should be used to test
 369 whether the thread is really the main one because NULL may also be returned for the thread
 370 not created with wxThread class. Generally speaking, the return value for such a thread
 371 is undefined.
 372
 373
 374 \membersection{wxThread::Yield}\label{wxthreadyield}
 375
 376 \func{void}{Yield}{\void}
 377
 378 Give the rest of the thread time slice to the system allowing the other threads to run.
 379 See also \helpref{Sleep()}{wxthreadsleep}.
 380
 381
 382 \membersection{wxThread::Wait}\label{wxthreadwait}
 383
 384 \constfunc{ExitCode}{Wait}{\void}
 385
 386 Waits until the thread terminates and returns its exit code or {\tt (ExitCode)-1} on error.
 387
 388 You can only Wait() for joinable (not detached) threads.
 389
 390 This function can only be called from another thread context.
 391