Passing Struct Array to a Thread - c

Question

I am trying to pass a whole array of a struct to a thread, where I need to have their index to differentiate the different arrays inside the thread.
typedef struct {
int x;
int y;
} StructA;
typedef struct {
StructaA str;
pthread_mutex_t* mutex;
} Parameters;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int n=3;
main(){
pthread_t thread;
StructA str[n];
Parameters thParam[n];
for (int i=0; i<n; i++){
thParam[i].str = &str[i];
thParam[i].mutex = &mutex;
}
for (int i=0; i<n; i++){
if(pthread_create(&thread[i], NULL, &Thread1, (void*)&thParam))
exit;
}
etc...
}
Thread1(params*){
Parameters * param[n];
StructA stra[n];
for (int i=0; i<n; i++){
??????????????????
}
}
I have thought about something like this:
for(int i=0; i<ghostN; i++){
param[i] = ((Parameters*) params+i);
stra[i] = param[i];
}
but I am just messing more and more the code. What would be the correct way to do this?
Consider that I must do this in order to see each str[n] values (the struct inside the main which I passed to the thread) inside the thread itself.

Answer 1

The memory of the main process is shared between all thereads. So, every thread has an ability to access the same variable or
arrays. The only thing which makes sense to pass to a thread startup function is somethign uniquie. Note, you cannot pass anything
to a thread, thread is not a function, but you can pass something to the thread start-up function to keep it on the stack of this
function. Every call to a function allocates stack unique to this function.
So, in your example I would keep the thParam array in the global scope to make it accessible by all threads, something like the following
Parameters thParam[n];
StructA str[n];
void *startThread(void *arg) {
long int i = (long int)arg;
use(thParam[i]);
}
main(){
pthread_t thread[n];
for (long int i=0; i<n; i++){
thParam[i].str = &str[i];
thParam[i].mutex = &mutex;
}
for (int i=0; i<n; i++){
if(pthread_create(&thread[i], NULL, &startThread, (void*)i))
exit;
}
...
}
Note that in the above case all writes to thParam is done before the thread starts. So there is no need to provide any
synchronization here. Also, since all threads access their own portion of the array only, defined by i, there is no need to
synchronize either.
You need to pass i by value, to avoid synchronization issues. Therefore you'd better have 'long int' to match its size to the size of the void* pointer.
And in your cases the thread must be an array as well.