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.