I have the following functions :
void *foo(void *i) {
int a = (int) i;
}
int main() {
pthread_t thread;
int i;
pthread_create(&thread, 0, foo, (void *) i);
}
At compilation, there are some errors about casting ((void *) i and int a = (int) i). How can I pass an integer as the last argument of pthread_create properly?
Building on szx's answer (so give him the credit), here's how it would work in your for loop:
void *foo(void *i) {
int a = *((int *) i);
free(i);
}
int main() {
pthread_t thread;
for ( int i = 0; i < 10; ++1 ) {
int *arg = malloc(sizeof(*arg));
if ( arg == NULL ) {
fprintf(stderr, "Couldn't allocate memory for thread arg.\n");
exit(EXIT_FAILURE);
}
*arg = i;
pthread_create(&thread, 0, foo, arg);
}
/* Wait for threads, etc */
return 0;
}
On each iteration of the loop, you're allocating new memory, each with a different address, so the thing that gets passed to pthread_create() on each iteration is different, so none of your threads ends up trying to access the same memory and you don't get any thread safety issues in the way that you would if you just passed the address of i. In this case, you could also set up an array and pass the addresses of the elements.
int *arg = malloc(sizeof(*arg)); should instead be int *arg = malloc(sizeof(arg));. Here it works because a pointer on most machines is the size of int. However it may fail for other data types or even custom types. Correct me if I am wrong here –
Justus int, not for a pointer to int. Your alternative would do the latter, so it's actually your suggestion that would only work if pointers and ints are the same size. –
Foxtail int *arg = malloc(sizeof(*arg)) in fact allocates space for a pointer rather a double pointer (consider *arg is in fact a pointer to a pointer to an int). I am still not convinced with your answer sir –
Justus int. int * arg = malloc(sizeof(&arg)); would allocate space for a pointer to pointer to int. If you're "not convinced", then you're just confused about basic C syntax. –
Foxtail arg means in the statement int * arg = malloc(sizeof(&arg));. To me it looks like an integer pointer and thus sizeof(arg) should obviously refer to an integer pointer. Building on that, sizeof(&arg) should refer to a pointer to a pointer to an int. To me this looks like were referring a pointer not to the base type which is int. If this is wrong, could you please elaborate a bit? Could you start with what arg in that statement means? –
Justus arg here is type int *, therefore &arg is type int ** and *arg is type int. Since you want to allocate space for an int, int * arg = malloc(sizeof(*arg)); is the correct way to do it. –
Foxtail int * arg = malloc(sizeof(&arg)); would "allocate space for a pointer to pointer to int", to respond to your mistaken supposition in your preceding comment that int *arg = malloc(sizeof(*arg)); would do that, which it wouldn't. In the actual code, we don't want to allocate space for a pointer to pointer to int - we want to allocate space for an int. –
Foxtail printf("%d\n", a), since POSIX requires printf() to be thread-safe. –
Foxtail You can allocate an int on the heap and pass it to pthread_create(). You can then deallocate it in your thread function:
void *foo(void *i) {
int a = *((int *) i);
free(i);
}
int main() {
pthread_t thread;
int *i = malloc(sizeof(*i));
pthread_create(&thread, 0, foo, (void *) i);
}
int a = *((int *) i), the for loop could have changed the value of i. Thus, when the first thread tries to initialize a, it would not read the right value. Or maybe I am confused with the concept of threads? –
Accent You should cast the address of i (rather than the value of i as you do now) in the last argument of pthread_create().
pthread_create(&thread, 0, foo, (void *) &i);
^ is missing
And the casting is wrong in your function too. It should be:
int a = *((int*) i);
i to some value in main() as it's uninitialized now.2 Use proper definition for main():
int main(void)
or int main(int argc, char *argv[]) or its equivalent.
i is declared in a for loop? For example for (int i=0;...;...) Or should I declared it before the for loop? –
Accent -std=c99 for example, along with other compiler options. –
Calorific &i, then I give the thread the address of variable i. If I create other threads, wouldn't i be shared between all threads? That would not be the desired behavior. –
Accent for loop that creates threads. Is there a way to pass an integer as the forth argument of pthread_create so that each thread has its own value, independent in each thread? Or maybe I have to create a variable for each thread? –
Accent int a = *((int *) i), the for loop could have changed the value of i. Thus, when the first thread tries to initialize a, it would not read the right value. –
Accent int to a pointer and back are implementation-defined, so this is not a great solution, either. Using malloc() is the best way. –
Foxtail Old question, but I faced the same problem today, and I decided not to follow this path.
My application was really about performance, so I chose to have this array of ints declared statically.
Since I don't know a lot of applications where your pthread_join / pthread_cancel is in another scope than your pthread_create, I chose this way :
#define NB_THREADS 4
void *job(void *_i) {
unsigned int i = *((unsigned int *) _i);
}
int main () {
unsigned int ints[NB_THREADS];
pthread_t threads[NB_THREADS];
for (unsigned int i = 0; i < NB_THREADS; ++i) {
ints[i] = i;
pthread_create(&threads[i], NULL, job, &ints[i]);
}
}
I find it more elegant, more efficient, and you don't have to worry about freeing since it only lives in this scope.
While this is an old question there is one option missing when all you need is to pass a positive integer like a descriptor: you can pass it directly as the address, while it it a hack it works well and avoid allocating anything :)
NOTE: the size of the integer must match the size of a pointer on your OS but nowadays most systems are native 64bits.
#include <pthread.h>
#include <inttypes.h>
#include <stdio.h>
void *_thread_loop(void *p)
{
uint64_t n = (uint64_t)p;
printf("received %llu\n", n);
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t read_thread_id;
uint64_t n = 42;
pthread_create(&read_thread_id, NULL, _thread_loop, (void *)n);
pthread_join(read_thread_id, NULL);
return 0;
}
you can intprt_t
Using intptr_t is useful when you need to convert between pointers and integers without loss of information or when you want to ensure that a pointer can be safely converted to an integer type. It's commonly used in scenarios where you need to store a pointer in an integer variable or pass a pointer as an integer argument to a function.
void *foo(void *i) {
int a = (intptr_t)i;
}
int main() {
pthread_t thread;
int i;
pthread_create(&thread, 0, foo, (void *)(intptr_t)i); // cast i to intptr_t type
}
© 2022 - 2024 — McMap. All rights reserved.
error: invalid conversion from ‘void*’ to ‘int*’at this line :int *arg = malloc(sizeof(*arg));. You should put (int *) before malloc. – Accent