Thread-Specific Data API

Last time it was making function thread safe or reentrant via thread local storage, now more complicated thread-specific data. Everything happens on Linux but should be applicable on any UNIX since we are using POSIX.
This one is also called thread-private data API. It creates per thread and per reentrant function storage. Process starts with key creation when thread for the first time calls function, any thread. In order to have key created once pthread_once is used. Then, once we got key, pthread_getspecific and pthread_setspecific are used to deal with thread-specific data. Here is example:

#include <pthread.h> #include <stdio.h> #include <stdlib.h> #define MAXSSZ 128 static pthread_once_t once = PTHREAD_ONCE_INIT; static pthread_key_t key; static void ctor(void){ int err; err = pthread_key_create(&key, free); if (err != 0){ perror("pthread_key_create failed"); exit(1); } } char * reentrant(char * msg){ char * storage; int err; err = pthread_once(&once, ctor); if (err != 0){ perror("pthread_once failed"); exit(1); } storage = pthread_getspecific(key); if (storage == NULL) { storage = malloc(MAXSSZ); if (storage == NULL){ perror("out of memory?"); exit(1); } err = pthread_setspecific(key, storage); if (err != 0){ perror("pthread_setspecific failed"); exit(1); } } if(msg != NULL) snprintf(storage, MAXSSZ, "Message is '%s'", msg); return storage; } static void * threadFunc(void *arg) { char *str; str = reentrant("Hello I am lumberjack!"); printf("From thread: %s\n", str); sleep(1); str = reentrant(NULL); printf("Again thread: %s\n", str); return NULL; } int main(int argc, char *argv[]) { pthread_t t; int err; char *str; str = reentrant("Hello from main!"); printf("Main message: %s\n", str); err = pthread_create(&t, NULL, threadFunc, NULL); if (err != 0){ perror("pthread_create failed"); exit(1); } str = reentrant("I am not lumberjack!"); err = pthread_join(t, NULL); if (err != 0){ perror("pthread_join failed"); exit(1); } printf("Main message: %s\n", str); return 0; }

To compile it the following is used:

gcc -o tsdexample tsdexample.c -pthread

Result of execution is:

Main message: Message is 'Hello from main!'
From thread: Message is 'Hello I am lumberjack!'
Again thread: Message is 'Hello I am lumberjack!'
Main message: Message is 'I am not lumberjack!'

In order to init static variable once, macro  PTHREAD_ONCE_INIT is used. During key creation destructor, ordinary free, is passed as parameter to pthread_key_create. Main thread and another thread then are calling reentrant function and setting and retrieving messages which are thread specific, what is expected. If we want to delete key it looks like this:

if(&key != NULL){ err = pthread_key_delete(key); if (err != 0){ perror("pthread_key_delete failed"); exit(1); } }

Though in example program it is static variable and it will go out of scope together with program.