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, may 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.

Once a key has been created, each thread may 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.

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.

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

For each argument you pass to the executable of this example, a thread is created and privately bound to the string-value of that argument.

/* cc thisfile.c */

#include <thread.h>

#define _REENTRANT
void *thread_specific_data(), free();
#define MAX_ARGC 20
thread_t tid[MAX_ARGC];
int num_threads;

main( int argc, char *argv[] ) {
  int i;
  num_threads = argc - 1;
  for( i = 0; i < num_threads; i++)
     thr_create(NULL, 0, thread_specific_data, argv[i+1], 0, &tid[i]);
  for( i = 0; i < num_threads; i++)
     thr_join(tid[i], NULL, NULL);
}  /* end main */

void *thread_specific_data(char private_data[])
{
  static mutex_t keylock; /* static ensures only one copy of keylock */
  static thread_key_t key;
  static int once_per_keyname = 0;
  void *tsd = NULL;

  if (!once_per_keyname) {     
       mutex_lock(&keylock);
       if (!once_per_keyname)  {
             thr_keycreate(&key, free);
             once_per_keyname++;
  }
       mutex_unlock(&keylock);
  }
  thr_getspecific(key, &tsd);
  if (tsd == NULL) {
       tsd = (void *)malloc(strlen(private_data) + 1);
       strcpy(tsd, private_data);
       thr_setspecific(key, tsd);
       thr_getspecific(key, &tsd);
       printf("tsd for %d = %s\n",thr_self(), tsd);
       thr_getspecific(key, &tsd);
       printf("tsd for %d remains %s\n",thr_self(), tsd);
         }
}  /* end thread_specific_data */

void
free(void *v)   {
  /* application-specific clean-up function */
}