Description

Create Key

In general, thread key creation allocates a key that locates data
specific to each thread in the process. The key is global to
all threads in the process, which allows each thread to bind a
value to the key once the key has been created. The key
independently maintains specific values for each binding thread. The thr_keycreate() function allocates
a global key namespace, pointed to by keyp, that is visible to
all threads in the process. Each thread is initially bound to a
private element of this key, which allows access to its thread-specific data.

Upon key creation, a new key is assigned the value NULL
for all active threads. Additionally, upon thread creation, all previously created keys
in the new thread are assigned the value NULL.

Optionally, a destructor function destructor can be associated with each key.
Upon thread exit, if a key has a non-null destructor function and
the thread has a non-null value associated with that key, the destructor function
is called with the current associated value. If more than one destructor
exists for a thread when it exits, the order of destructor calls
is unspecified.

An exiting thread runs with all signals blocked. All thread termination functions,
including thread-specific data destructor functions, are called with all signals blocked.

The thr_keycreate_once() function is identical to the thr_keycreate() function except that the
key pointed to by keyp must be statically initialized with the value
THR_ONCE_KEY before calling thr_keycreate_once() and the key will be created exactly once.
This is equivalent to using pthread_once() to call a onetime initialization
function that calls thr_keycreate() to create the data key.

Set Value

Once a key has been created, each thread can bind a new
value to the key using thr_setspecific(). The values are unique to the
binding thread and are individually maintained. These values continue for
the life of the calling thread.

Proper synchronization of key storage and access must be ensured by
the caller. The value argument to thr_setspecific() is generally a pointer to
a block of dynamically allocated memory reserved by the calling thread for
its own use. See EXAMPLES below.

At thread exit, the destructor function, which is associated at time of
creation, is called and it uses the specific key
value as its sole argument.

Get Value

thr_getspecific() stores the current value bound to key for the calling thread
into the location pointed to by valuep.

Return Values

If successful, thr_keycreate(), thr_keycreate_once(), thr_setspecific() and thr_getspecific() return 0. Otherwise, an error
number is returned to indicate the error.

Errors

If the following conditions occur, thr_keycreate() and thr_keycreate_once() return the corresponding error
number:

EAGAIN

The system lacked the necessary resources to create another thread-specific data key.

ENOMEM

Insufficient memory exists to create the key.

If the following conditions occur, thr_setspecific() returns the corresponding error number:

Examples

Example 1 Call the thread-specific data from more than one thread without special initialization.

In this example, the thread-specific data in this function can be called
from more than one thread without special initialization. For each argument passed
to the executable, a thread is created and privately bound to
the string-value of that argument.

See Also

Warnings

The thr_getspecific() and thr_setspecific() functions can be called either explicitly or
implicitly from a thread-specific data destructor function. Calling thr_setspecific() from a destructor
can result in lost storage or infinite loops.