C passing shared variables into pthreads - c

Question

I wrote the following program to test some assumptions I have about pthreads:
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
typedef struct threadArgs * ThreadArgs;
void *foo( void * argStruct );
struct threadArgs{
int pingBool;
};
int main(int argc, char const *argv[]){
pthread_t t1;
int pingBool = 1;
int ch;
ThreadArgs args = (ThreadArgs)malloc(sizeof(struct threadArgs));
args->pingBool = pingBool;
pthread_create(&t1, NULL, foo, args);
while((ch = getchar()) != EOF ){
if( ch == 'q' ){
pingBool = 0;
printf("pingBool now 0\n");
break;
}
}
pthread_join(t1, NULL);
printf("whole program terminating\n");
return 0;
}
void *foo( void * argStruct ){
ThreadArgs args = argStruct;
while( args->pingBool == 1 ){
printf("t1 still going\n");
sleep(1);
}
printf("t1 finished\n");
return NULL;
}
Basically, it sets a variable int pingBool = 1 in main(), passes it into a thread which loops until pingBool == 0. main() then sets pingBool = 0, however, the thread continues to run. I'm pretty sure this is happening because pingBool is getting copied when it is put into the struct and only the copy local to main() is being modified.
Is there a way to share and modify variables between threads like this? I am aware that I can simply make pingBool a global variable rather than pass it into foo(). However, I would prefer not to do that.
Note: If you want to test the code you need to compile with -pthread or -lpthread depending on your compiler. i.e. gcc -Wall -Werror -pthread -o test test.c

Answer 1

You already are sharing the variable between two threads - it's just that you're not referring to the shared copy in main. To refer to the shared copy, main needs to use args->pingBool.
However, your code will then not be correct, because it will have a data race - two threads aren't allowed to access a shared variable without using a synchronisation function. To fix that, you can use a mutex:
struct threadArgs {
pthread_mutex_t lock;
int pingBool;
};
It will need to be initialised:
ThreadArgs args = (ThreadArgs)malloc(sizeof(struct threadArgs));
pthread_mutex_init(&args->lock, NULL);
main should lock the mutex when changing args->pingBool:
if ( ch == 'q' ) {
pthread_mutex_lock(&args->lock);
args->pingBool = 0;
pthread_mutex_unlock(&args->lock);
printf("pingBool now 0\n");
break;
}
and the thread should lock it while reading it:
pthread_mutex_lock(&args->lock);
while ( args->pingBool == 1 ) {
pthread_mutex_unlock(&args->lock);
printf("t1 still going\n");
sleep(1);
pthread_mutex_lock(&args->lock);
}
pthread_mutex_unlock(&args->lock);

Answer 2

Nevermind, solved it myself. The trick was to pass in a pointer to the original variable and access the value of that pointer from foo(). Ammended code:
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
typedef struct threadArgs * ThreadArgs;
void *foo( void * argStruct );
struct threadArgs{
int *pingBool; // Now a pointer, not an int
};
int main(int argc, char const *argv[]){
pthread_t t1;
int pingBool = 1;
int ch;
ThreadArgs args = (ThreadArgs)malloc(sizeof(struct threadArgs));
args->pingBool = &pingBool; // pass in a pointer to the variable, rather than the variable itself
pthread_create(&t1, NULL, foo, args);
while((ch = getchar()) != EOF ){
if( ch == 'q' ){
pingBool = 0;
printf("pingBool now 0\n");
break;
}
}
pthread_join(t1, NULL);
printf("whole program terminating\n");
return 0;
}
void *foo( void * argStruct ){
ThreadArgs args = argStruct;
int * pingBool = args->pingBool;
while( *pingBool == 1 ){ // access the value of the pointer
printf("t1 still going\n");
sleep(1);
}
printf("t1 finished\n");
return NULL;
}

Answer 3

Try passing args by reference to pthread_create(). It would look like:
pthread_create(&t1, NULL, foo, &args);