1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
PR_CreateThread
===============
Creates a new thread.
Syntax
------
.. code::
#include <prthread.h>
PRThread* PR_CreateThread(
PRThreadType type,
void (*start)(void *arg),
void *arg,
PRThreadPriority priority,
PRThreadScope scope,
PRThreadState state,
PRUint32 stackSize);
Parameters
~~~~~~~~~~
:ref:`PR_CreateThread` has the following parameters:
``type``
Specifies that the thread is either a user thread
(``PR_USER_THREAD``) or a system thread (``PR_SYSTEM_THREAD``).
``start``
A pointer to the thread's root function, which is called as the root
of the new thread. Returning from this function is the only way to
terminate a thread.
``arg``
A pointer to the root function's only parameter. NSPR does not assess
the type or the validity of the value passed in this parameter.
``priority``
The initial priority of the newly created thread.
``scope``
Specifies your preference for making the thread local
(``PR_LOCAL_THREAD``), global (``PR_GLOBAL_THREAD``) or global bound
(``PR_GLOBAL_BOUND_THREAD``). However, NSPR may override this
preference if necessary.
``state``
Specifies whether the thread is joinable (``PR_JOINABLE_THREAD``) or
unjoinable (``PR_UNJOINABLE_THREAD``).
``stackSize``
Specifies your preference for the size of the stack, in bytes,
associated with the newly created thread. If you pass zero in this
parameter, :ref:`PR_CreateThread` chooses the most favorable
machine-specific stack size.
Returns
~~~~~~~
The function returns one of the following values:
- If successful, a pointer to the new thread. This pointer remains
valid until the thread returns from its root function.
- If unsuccessful, (for example, if system resources are unavailable),
``NULL``.
Description
-----------
If you want the thread to start up waiting for the creator to do
something, enter a lock before creating the thread and then have the
thread's root function enter and exit the same lock. When you are ready
for the thread to run, exit the lock. For more information on locks and
thread synchronization, see `Introduction to
NSPR <Introduction_to_NSPR>`__.
If you want to detect the completion of the created thread, make it
joinable. You can then use :ref:`PR_JoinThread` to synchronize the
termination of another thread.
|
