Safe way to pass parameters into a thread

Question

Can you clarify, why the following code is a safe way to pass parameters into the new thread:

//Listing 5.3 Passing a Value into a Created Thread
for ( int i=0; i<10; i++ )
    pthread_create( &thread, 0, &thread_code, (void *)i );

And the following code isn't:

//Listing 5.4 Erroneous Way of Passing Data to a New Thread
for ( int i=0; i<10; i++ )
    pthread_create( &thread, 0, &thread_code, (void *)&i );

Quote from the book,regarding the code:

It is critical to realize that the child thread can start executing at any point after the call, so the pointer must point to something that still exists and still retains the same value. This rules out passing in pointers to changing variables as well as pointers to information held on the stack (unless the stack is certain to exist until after the child thread has read the value).

Answer 1

A third method is good as given below:

static int args[10];
for ( int i=0; i<10; i++ ) {
    args[i] = i;
    pthread_create( &thread, 0, &thread_code, (void *)&args[i] );
}

If you want same variable shared across all the threads, make a local variable in main or preferably and static or global variable.

Issues with method 1 and method 2:

Method 1 You are casting an int to void * and then back to int which is bad as the size of int and void * may be different. If you plan to cast void * to int *, it is even worse and an UB. Also read this post.

Method 2 You are passing same address to all threads. When i is changed from main thread of any of the 10 worker threads same value would be reflected everywhere which may not be your intention. Moreover scope of i ends after the for loop, and you may end up accessing dangling pointers in threads. and would cause UB. (undefined behaviour)

Answer 2

Why is the second example wrong?

As your citation says, you must not pass a pointer to the interation variable because it gets changed quickly. You never know when exactly the concurrent thread will use the pointer and dereference it.

// Listing 5.4 Erroneous Way of Passing Data to a New Thread
for ( int i=0; i<10; i++ )
    pthread_create( &thread, 0, &thread_code, (void *)&i );

Imagine the very first call to pthread_create(). It receives a pointer to i and will probably dereference the pointer and read the value. Your value is supposed to be 0 at the time. But your main thread (the one with the for loop) may have already changed i from 0 to 1. That is called a race condition because your program depends on whether one thread is faster to change the value or the other is faster to get it.

There's a second race condition as well, as your i variable will get out of scope at the end of the loop. If the threads were slow to start or to read the pointer target, the address on the stack can already be allocated to something else. You must not dereference pointers to variables that no longer exist.

Why the first doesn't have the same problem?

The first example uses the value of i, not it's address. That is good, as pthread_create() will just hold the value and pass it to the thread.

// Listing 5.3 Passing a Value into a Created Thread
for ( int i=0; i<10; i++ )
    pthread_create( &thread, 0, &thread_code, (void *)i );

But pthread_create() only accepts void * (a generic pointer). The example uses a special trick where you cast the integer value to a pointer value. It is expected that the thread function will do the reverse (will cast the pointer back to integer).

This trick is often used to store an integer value where an object is expected, as it avoids having to allocate and deallocate the object. Whether such a technique is good or bad practice is out of scope of a factual answer. It's being used in frameworks like GLib but I guess many programmers will scorn it.

Final notes

The examples in the book are clearly not solutions for real problems but just motivation examples. In actual code, you would rarely pass just an integer value and you might want to join the thread at some point of time. Therefore in a simple scenario you would have to allocate the thread arguments, fill them in, start the workers, join the workers, retrieve the results and free the allocations.

In a more complicated scenario you would communicate with the threads and therefore you wouldn't be limited to feeding them at their creation and retreiving the results after joining them. You could even just let the workers run and reuse them whenever you need them.