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 safely be used with joinable threads, not
 207 detached ones as the latter delete themselves and so when the real thread is
 208 no longer alive, it is not possible to call this function because
 209 the wxThread object no longer exists.
 210
 211 \membersection{wxThread::IsDetached}\label{wxthreadisdetached}
 212
 213 \constfunc{bool}{IsDetached}{\void}
 214
 215 Returns \true if the thread is of the detached kind, \false if it is a joinable
 216 one.
 217
 218
 219 \membersection{wxThread::IsMain}\label{wxthreadismain}
 220
 221 \func{static bool}{IsMain}{\void}
 222
 223 Returns \true if the calling thread is the main application thread.
 224
 225
 226 \membersection{wxThread::IsPaused}\label{wxthreadispaused}
 227
 228 \constfunc{bool}{IsPaused}{\void}
 229
 230 Returns \true if the thread is paused.
 231
 232
 233 \membersection{wxThread::IsRunning}\label{wxthreadisrunning}
 234
 235 \constfunc{bool}{IsRunning}{\void}
 236
 237 Returns \true if the thread is running.
 238
 239 This method may only be safely used for joinable threads, see the remark in
 240 \helpref{IsAlive}{wxthreadisalive}.
 241
 242
 243 \membersection{wxThread::Kill}\label{wxthreadkill}
 244
 245 \func{wxThreadError}{Kill}{\void}
 246
 247 Immediately terminates the target thread. {\bf This function is dangerous and should
 248 be used with extreme care (and not used at all whenever possible)!} The resources
 249 allocated to the thread will not be freed and the state of the C runtime library
 250 may become inconsistent. Use \helpref{Delete()}{wxthreaddelete} instead.
 251
 252 For detached threads Kill() will also delete the associated C++ object.
 253 However this will not happen for joinable threads and this means that you will
 254 still have to delete the wxThread object yourself to avoid memory leaks.
 255 In neither case \helpref{OnExit}{wxthreadonexit} of the dying thread will be
 256 called, so no thread-specific cleanup will be performed.
 257
 258 This function can only be called from another thread context, i.e. a thread
 259 cannot kill itself.
 260
 261 It is also an error to call this function for a thread which is not running or
 262 paused (in the latter case, the thread will be resumed first) -- if you do it,
 263 a {\tt wxTHREAD\_NOT\_RUNNING} error will be returned.
 264
 265
 266 \membersection{wxThread::OnExit}\label{wxthreadonexit}
 267
 268 \func{void}{OnExit}{\void}
 269
 270 Called when the thread exits. This function is called in the context of the
 271 thread associated with the wxThread object, not in the context of the main
 272 thread. This function will not be called if the thread was
 273 \helpref{killed}{wxthreadkill}.
 274
 275 This function should never be called directly.
 276
 277
 278 \membersection{wxThread::Pause}\label{wxthreadpause}
 279
 280 \func{wxThreadError}{Pause}{\void}
 281
 282 Suspends the thread. Under some implementations (Win32), the thread is
 283 suspended immediately, under others it will only be suspended when it calls
 284 \helpref{TestDestroy}{wxthreadtestdestroy} for the next time (hence, if the
 285 thread doesn't call it at all, it won't be suspended).
 286
 287 This function can only be called from another thread context.
 288
 289
 290 \membersection{wxThread::Run}\label{wxthreadrun}
 291
 292 \func{wxThreadError}{Run}{\void}
 293
 294 Starts the thread execution. Should be called after
 295 \helpref{Create}{wxthreadcreate}.
 296
 297 This function can only be called from another thread context.
 298
 299
 300 \membersection{wxThread::SetPriority}\label{wxthreadsetpriority}
 301
 302 \func{void}{SetPriority}{\param{int}{ priority}}
 303
 304 Sets the priority of the thread, between $0$ and $100$. It can only be set
 305 after calling \helpref{Create()}{wxthreadcreate} but before calling
 306 \helpref{Run()}{wxthreadrun}.
 307
 308 The following priorities are already defined:
 309
 310 \twocolwidtha{7cm}
 311 \begin{twocollist}\itemsep=0pt
 312 \twocolitem{{\bf WXTHREAD\_MIN\_PRIORITY}}{0}
 313 \twocolitem{{\bf WXTHREAD\_DEFAULT\_PRIORITY}}{50}
 314 \twocolitem{{\bf WXTHREAD\_MAX\_PRIORITY}}{100}
 315 \end{twocollist}
 316
 317
 318 \membersection{wxThread::Sleep}\label{wxthreadsleep}
 319
 320 \func{static void}{Sleep}{\param{unsigned long }{milliseconds}}
 321
 322 Pauses the thread execution for the given amount of time.
 323
 324 This function should be used instead of \helpref{wxSleep}{wxsleep} by all worker
 325 threads (i.e. all except the main one).
 326
 327
 328 \membersection{wxThread::Resume}\label{wxthreadresume}
 329
 330 \func{wxThreadError}{Resume}{\void}
 331
 332 Resumes a thread suspended by the call to \helpref{Pause}{wxthreadpause}.
 333
 334 This function can only be called from another thread context.
 335
 336
 337 \membersection{wxThread::SetConcurrency}\label{wxthreadsetconcurrency}
 338
 339 \func{static bool}{SetConcurrency}{\param{size\_t }{level}}
 340
 341 Sets the thread concurrency level for this process. This is, roughly, the
 342 number of threads that the system tries to schedule to run in parallel.
 343 The value of $0$ for {\it level} may be used to set the default one.
 344
 345 Returns \true on success or false otherwise (for example, if this function is
 346 not implemented for this platform -- currently everything except Solaris).
 347
 348
 349 \membersection{wxThread::TestDestroy}\label{wxthreadtestdestroy}
 350
 351 \func{virtual bool}{TestDestroy}{\void}
 352
 353 This function should be called periodically by the thread to ensure that calls
 354 to \helpref{Pause}{wxthreadpause} and \helpref{Delete}{wxthreaddelete} will
 355 work. If it returns \true, the thread should exit as soon as possible.
 356
 357 Notice that under some platforms (POSIX), implementation of
 358 \helpref{Pause}{wxthreadpause} also relies on this function being called, so
 359 not calling it would prevent both stopping and suspending thread from working.
 360
 361
 362 \membersection{wxThread::This}\label{wxthreadthis}
 363
 364 \func{static wxThread *}{This}{\void}
 365
 366 Return the thread object for the calling thread. NULL is returned if the calling thread
 367 is the main (GUI) thread, but \helpref{IsMain}{wxthreadismain} should be used to test
 368 whether the thread is really the main one because NULL may also be returned for the thread
 369 not created with wxThread class. Generally speaking, the return value for such a thread
 370 is undefined.
 371
 372
 373 \membersection{wxThread::Yield}\label{wxthreadyield}
 374
 375 \func{void}{Yield}{\void}
 376
 377 Give the rest of the thread time slice to the system allowing the other threads to run.
 378 See also \helpref{Sleep()}{wxthreadsleep}.
 379
 380
 381 \membersection{wxThread::Wait}\label{wxthreadwait}
 382
 383 \constfunc{ExitCode}{Wait}{\void}
 384
 385 Waits until the thread terminates and returns its exit code or {\tt (ExitCode)-1} on error.
 386
 387 You can only Wait() for joinable (not detached) threads.
 388
 389 This function can only be called from another thread context.
 390