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.

C++ and pthreads on Linux

If one wants to use NDK and that is JNI on Android, sooner or later he will run into threading on Linux, yes Android is Linux. Pthreads is short for POSIX threads where POSIX is Portable Operating System Interface. Since they are portable they will work on Unix, Linux, FreeBSD, Mac and so on. Pthread is defined in pthread.h and represents set of C functions, structs and defs, to discover where it is you can execute from terminal:

$ locate pthread.h

If you have NDK installed you will see that pthread.h is part of it and that arch-arm version is significantly smaller than /usr/include/pthread.h one. To cut long story short we can do Hello World and see how it looks like:

extern "C" { #include <pthread.h> } #include <iostream> using namespace std; void* callback(void* arg){ cout << *(reinterpret_cast<string*>(arg)) << endl; return 0; } int main( void ){ pthread_t thread; string hello("Hello World!"); int res = pthread_create( &thread,NULL, callback,reinterpret_cast<void*>(&hello)); if (res != 0){ cout << "pthread_create failed" << endl; return 1; } res = pthread_join(thread,NULL); if (res != 0){ cout << "pthread_join failed" << endl; return 1; } cout << "that's all folks" << endl; return 0; }

It is quite simple, we declare thread function, thread itself and then we create thread and pass function pointer and argument in pthread_create. Later we join and exit. To compile it we do:

g++ -pthread simple.cpp -o simple

That -pthread switch is linking instruction. Now cout is not thread safe and we may want to use mutex to make printing to standard output safe.

extern "C" { #include <pthread.h> } #include<iostream> #define NTHREADS 8 using namespace std; pthread_mutex_t mutex; void* function(void* arg){ int index=*(static_cast<int*>(arg)); pthread_mutex_lock(&mutex); cout<<"Hello from thread "<<index<<endl; pthread_mutex_unlock(&mutex); return 0; } int main(){ pthread_mutex_init(&mutex,NULL); pthread_t threads[NTHREADS]; int thread_no[NTHREADS]; for(int i=0;i<NTHREADS;++i){ thread_no[i] = i; pthread_create(&threads[i],NULL,function,static_cast<void*>(&thread_no[i])); } for(int i=0;i<NTHREADS;++i) pthread_join(threads[i],NULL); pthread_mutex_destroy(&mutex); return 0; }

Now one can go and wrap pthread or mutex in class and make it easier to use. Only we need to be careful with that function pointer in pthread_create, that is C function and passing class method won’t work without some additional coding and static casting.
Finally we will take a look at pthread_key_create, which is recommended by Android documentation. Its signature is:

int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));

That "destructor" should free resources taken by key when thread exits. Key itself is global variable but on thread level, sort of locally global. So here is example:

extern "C" { #include <pthread.h> #include <stdlib.h> #include <string.h> } #include <iostream> #include <string> #include <sstream> using namespace std; #define NTHREADS 4 pthread_key_t that_key; struct payload{ char* data; int size; } *load; void free_key(void* arg){ payload* s = (payload*)arg; free(s->data); free(s); } void* thread_func(void* param) { cout<<"in thread "<<pthread_self()<<endl; pthread_setspecific(that_key, param); payload* s = static_cast<payload*>(pthread_getspecific(that_key)); cout<<"thread_func, data is "<<s->data<<" and size is "<<s->size<<endl; return NULL; } int main(){ pthread_key_create(&that_key, free_key); pthread_t thread[NTHREADS]; int i; for(i=0;i<NTHREADS;i++){ load = (payload*)malloc(sizeof(payload)); string s("this is test string "); ostringstream o; o<<s<<i; load->size = o.str().size(); load->data = static_cast<char*>(malloc(sizeof(char)*(o.str().size()+1))); memcpy(load->data, static_cast<const void*>(o.str().c_str()), o.str().size()); pthread_create(&thread[i], NULL, thread_func, static_cast<void*>(load)); } for (i=0; i <NTHREADS; ++i) { pthread_join(thread[i], NULL); } pthread_key_delete(that_key); return 0; }

When you build it and execute it you will see that cout is not thread safe. If you want to wrap pthread in class, very good reading is Implementation and Usage of a Thread Pool based on POSIX Threads by Ronald Kriemann, sorry do not have link for it. Beside mutex, there are are condition variables and semaphores to help with concurrency issues. If you are going to fork process you may want to use System V semaphores instead of pthread semaphores. Finally for any serious implementation of pthread_key_create you need to look at pthread_once_t.