Can anyone explain me how to use pthread_key_create() , pthread_setspecific(), pthread_getspecific() and pthread_key_delete () routines in pthreads.

Kindly state by an example.

pthread_key_create, creates a thread-specific data key.

#include<pthread.h>
int pthread_key_create ( key, destructor )
pthread_key_t * key;
void (*destructor) (void *);

- The pthread_key_create creates a thread-specific data key. The key is
shared among all threads within the process, but each thread has specific data
associated with the key. The thread-specific data is a void pointer, initially
set to NULL.

#include <pthread.h>
int pthread_setspecific(pthread_key_t key, const void *value);

- The pthread_setspecific() function associates a thread-specific data value with a key obtained via a previous call to pthread_key_create(). Different threads may bind different values to the same key. These values are typically pointers to blocks of dynamically allocated memory that have been reserved for use by the calling thread.

The effect of calling pthread_setspecific() with a key value not obtained from pthread_key_create() or after the key has been deleted with pthread_key_delete() is undefined.

#include <pthread.h>
int pthread_key_delete(pthread_key_t key);

- The pthread_key_delete() function deletes a thread-specific data key previously returned by pthread_key_create(). The thread-specific data values associated with the key need not be NULL at the time pthread_key_delete() is called. It is the responsibility of the application to free any application storage or perform any cleanup actions for data structures related to the deleted key or associated thread-specific data in any threads; this cleanup can be done either before or after pthread_key_delete(). Any attempt to use the key following the call to pthread_key_delete() results in undefined behavior.

pthread_key_delete() can be called from within destructor functions. No destructor functions are invoked by pthread_key_delete(). Any destructor function that may have been associated with the key is no longer called on thread exit.

#include <pthread.h>
void *pthread_getspecific(pthread_key_t key);

- The pthread_getspecific() function returns the value currently associated with the specified thread-specific data key. The effect of calling pthread_getspecific() with a key value not obtained from pthread_key_create() or after the key has been deleted with pthread_key_delete() is undefined. pthread_getspecific() may be called from a thread-specific data destructor function.

Thanks. But all this I have seen in the man pages. Actually I am unable to implement it in a program.

Here's an idea of how I tried to implement the above concepts:

I created a thread key and 2 threads in main and made the main waited untill all the threads were over. In one of the thread ( I assumed that it wil be called first) I binded a value to the key using pthread_setspecific. In the other thread I tried to restore the binded value to the key by calling pthread_getspecific routine. But the value returned by the later is a NULL value.

Kindly direct me as to where I am wrong. Kindly state an example in favour of it's lucid explanation and its implementation techniques.

Well I found out the problem myself. I should have used pthread_getspecific in the same thread instead of the other. But still I have one doubt - In the thread there is a cost overhead of calling set and get specific at intervals. If we declare static array variables of a type ( as many as there are threads ) , perhaps we can achive the same goal.
Is it safe enough to implement the concept in a medium scale project ?