C: How to safely and properly pass several arguments to a pthread?

Question

Consider this simple code:

void* threadFunction(void* arg) {

    int argument=(int)arg;

    printf("%d recieved\n", argument);

    return NULL;
}


int main(int argv, char* argc[]) {

    int error;
    int i=0;
    pthread_t thread;

    int argument_to_thread=0;

    if ((error=pthread_create(&thread, NULL, threadFunction, (void*)argument_to_thread))!=0) {
        printf("Can't create thread: [%s]\n", strerror(error));
        return 1;
    }

    pthread_join(thread, NULL);


    return 0;
}

This works, but two things bother me here.
First, I want to send more than one argument to threadFunction().
Of course, I can pass a pointer to an array, but what if I want to pass two arguments of different types? (say an int and char*) How can it be done?

The second thing that bothers me here, is the warnings I get when compiling the above...

test2.c: In function ‘threadFunction’:
test2.c:8:15: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  int argument=(int)arg;
               ^
test2.c: In function ‘main’:
test2.c:24:59: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  if ((error=pthread_create(&thread, NULL, threadFunction, (void*)argument_to_thread))!=0) {
                                                           ^

Now, I can make this go away by doing this:

if ((error=pthread_create(&thread, NULL, threadFunction, (void*)&argument_to_thread))!=0) {
    printf("Can't create thread: [%s]\n", strerror(error));
    return 1;
}

But let's say I don't want to pass it by reference... Is there way to pass, say... an int, by value as an argument without the compiler warning me?

Answer 1

There are two ways to do this:

1. Use malloc to obtain storage for the arguments structure, and have the new thread be responsible for calling free once it's done with the arguments. (Note: if pthread_create fails, you need to free this storage in the failure path.)

2. Use a semaphore (or other synchronization, but a semaphore is by far the lightest).

Here's an example of the latter:

struct args {
    int a;
    char *b;
    sem_t sem;
};

void *thread_func(void *p)
{
    struct args *args = p;
    int a = args->a;
    char *b = args->b;
    sem_post(args->sem);
    ...
}

    /* in caller */
    struct args args;
    args.a = ...;
    args.b = ...;
    sem_init(&args.sem, 0, 0);
    pthread_create(&tid, 0, thread_func, &args);
    sem_wait(&args.sem);
    ...

Answer 2

If you want to pass by value but make the warning go away, use this cast:

(void *)(uintptr_t)argument_to_thread

The intermediate cast through uintptr_t avoids the size mismatch. Similarly, when casting back, use:

(int)(uintptr_t)voidptr_arg

As noted in the comments, the above approach is not necessarily recommended because it relies on implementation-defined behavior. A fully portable approach, assuming you don't need the full range of int but only a small range, is:

static const char int_to_ptr_trick[MAXVAL];
void *ptr = int_to_ptr_trick + int_val;
int int_val = (char *)ptr - int_to_ptr_trick;

Answer 3

Pass the address of the integer.

int argument = 123 ;
pthread_create(&thread, NULL, threadFunction, &argument)) ;

and in the thread function

 int argument= *(int*)arg ;

If you wish to pass more than one argument you can create a struct holding your values, using the same approach as with the above example.

You cannot pass an integer by value if the parameter for the functions is void*. You will have to provide the address of the variable or struct.