A few days ago, we talked about building our first multi-thread programs using POSIX threads. But soon a need arises: share data between the main thread and the recently launched thread, at least to indicate what we want it to do.
So we can use the last argument of pthread_create(), this is a void pointer we can use for whatever we want and pass the variable type we want. For example an integer:
Related Articles
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #include <stdio.h> #include <stdlib.h> #include <pthread.h> void *newtask(void *_number) { int number = *(int*)_number; printf("The number I was asked for: %d\n", number); pthread_exit(NULL); } int main (int argc, char *argv[]) { pthread_t thread; int rc; int i; int number = 99; printf ("Main process just started.\n"); rc = pthread_create(&thread, NULL, newtask, &number); if (rc) { printf("ERROR in pthread_create(): %d\n", rc); exit(-1); } printf ("Main process about to finish.\n"); /* Last thing that main() should do */ pthread_exit(NULL); } |
Remember to compile using pthread:
$ gcc -o simplepass simplepass.c -lpthread
This way, the thread can read the value we’ve passed him, as we can see if we run this little program. Just after starting newtask() we extract the number from the void pointer to an integer variable. But working a bit on this code we can realize this variable can be bi-directional, in other words, we can write a value from the secondary thread, and the main thread can read it. (Instead of doing this, we can use global variables, but I don’t like it much):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | #include <stdio.h> #include <stdlib.h> #include <pthread.h> void *newtask(void *_number) { int *number = _number; printf("The number I was asked for: %d\n", *number); *number = 10; pthread_exit(NULL); } int main (int argc, char *argv[]) { pthread_t thread; int rc; int i; int number = 99; printf ("Main process just started.\n"); rc = pthread_create(&thread, NULL, newtask, &number); if (rc) { printf("ERROR in pthread_create(): %d\n", rc); exit(-1); } usleep(100000); printf (" Before exiting. Number = %d\n", number); printf ("Main process about to finish.\n"); /* Last thing that main() should do */ pthread_exit(NULL); } |
Now, if we want to pass multiple arguments to the secondary thread, we can create a struct which stores all variables we want to use there:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <string.h> struct thread_vars_t { int number; char string[50]; }; void *newtask(void *_number) { struct thread_vars_t *vars = _number; printf("The number I was asked for: %d\n", vars->number); vars->number = 10; strcpy(vars->string, "Hello world from thread"); pthread_exit(NULL); } int main (int argc, char *argv[]) { pthread_t thread; int rc; int i; struct thread_vars_t *vars = malloc (sizeof(struct thread_vars_t)); vars->number = 99; printf ("Main process just started.\n"); rc = pthread_create(&thread, NULL, newtask, vars); if (rc) { printf("ERROR in pthread_create(): %d\n", rc); exit(-1); } usleep(100000); printf (" Before exiting. Number = %d\n", vars->number); printf (" Before exiting. String = %s\n", vars->string); printf ("Main process about to finish.\n"); /* Last thing that main() should do */ pthread_exit(NULL); } |
In older and slower computers, we may have to cary the value passed to usleep(), I’m just simulating a wait, it could be the time taken by additional computation. But using a sleep could be a problem, depending on the computer capabilities this value must change, or we could give a high value to make it compatible with more computers, but it could be a waste of time for modern computers. We can solve it many ways, but this first one will be a demo of what you shouldn’t do making an active wait:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <string.h> struct thread_vars_t { int ready; int number; char string[50]; }; void *newtask(void *_number) { struct thread_vars_t *vars = _number; printf("The number I was asked for: %d\n", vars->number); vars->number = 10; strcpy(vars->string, "Hello world from thread"); vars->ready = 1; pthread_exit(NULL); } int main (int argc, char *argv[]) { pthread_t thread; int rc; int i; struct thread_vars_t *vars = malloc (sizeof(struct thread_vars_t)); vars->ready = 0; vars->number = 99; printf ("Main process just started.\n"); rc = pthread_create(&thread, NULL, newtask, vars); if (rc) { printf("ERROR in pthread_create(): %d\n", rc); exit(-1); } // usleep(100000); while (!vars->ready); printf (" Before exiting. Number = %d\n", vars->number); printf (" Before exiting. String = %s\n", vars->string); printf ("Main process about to finish.\n"); /* Last thing that main() should do */ pthread_exit(NULL); } |
In this case, we have a new variable (vars->ready), when it’s 1 it means the values are set by the secondary thread, so the main one can read them. The main thread, to wait for vars->ready is asking all the time for this value while it’s 0:
1 | while (!vars->ready); |
But it has a great disadvantage: the process is eating CPU while the condition is not met. We can see it clearer writing sleep(20) just before the secondary thread set ready to 1, and use a task manager to see how CPU use is going, our process will use a big percentage of CPU for nothing, just waiting. If we think about it and the secondary thread is doing any type of complex calculation, the main thread will be stealing CPU time obstructing the secondary one, making it slower, so we have to use another type of solution, like semaphores, signals, mutex, etc. But I’ll talk about them in another post.
Photo: OakleyOriginals (Flickr) CC-by
