Comment passer un tableau en tant que valeur de retour via un thread?

Je travaille sur une fonction qui crée un thread et calcule la séquence de Fibonacci à une certaine valeur saisie par l’utilisateur. Par exemple, si un utilisateur entre 5 , le résultat sera: 0 1 1 2 3 5

Cependant, la séquence doit être calculée dans le thread créé et les résultats doivent être imprimés après la sortie du thread.

Je peux créer le thread et calculer la séquence, mais je dois fibSequence[] le tableau fibSequence[] au thread d’origine en utilisant pthread_exit et pthread_join . J’ai du mal à comprendre la syntaxe et je ne trouve aucun exemple de passage de personnes à travers des tableaux.

Ce que j’ai jusqu’à présent: j’ai créé une fonction fib_runner() appelée par un nouveau thread. La séquence Fibonacci est créée et placée dans le tableau fibSequence[] . Je dois le transmettre à la fonction principale. J’imprime temporairement la séquence dans la fonction, mais elle devrait être imprimée dans la main.

Je vous remercie!

 #include  #include  #include  void* fib_runner(void* arg) { int *limit_ptr = (int*) arg; int limit = *limit_ptr; int fibSequence[limit]; int size = sizeof(fibSequence)/sizeof(fibSequence[0]); printf("Size: %d\n", size); fibSequence[0] = 0; fibSequence[1] = 1; for (int i = 2; i <= size; i++) { fibSequence[i] = fibSequence[i-1] + fibSequence[i-2]; } for (int i = 0; i <= size; i++) { printf("%d ", fibSequence[i]); } pthread_exit(0); } int main(int argc, char **argv) { int limit; printf("Enter Number: "); scanf("%d", &limit); pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_create(&tid, &attr, fib_runner, &limit); pthread_join(tid, NULL); }

Actuellement, le tableau est une variable locale, il serait donc hors de scope lorsque la fonction est fermée. Vous devez lui allouer dynamicment de la mémoire à la place:

 int *fibSequence = malloc(sizeof(int) * limit);

Puis renvoyez ce pointeur depuis la fonction:

 return fibSequence;

Dans votre fonction main , vous transmettez ensuite l’adresse d’un pointeur pour recevoir cette valeur. Ensuite, vous pouvez imprimer le contenu du tableau. Lorsque vous avez terminé, assurez-vous de le free :

 int *fibSequence; pthread_join(tid, (void **)&fibSequence); for (int i = 0; i < limit; i++) { printf("%d ", fibSequence[i]); } free(fibSequence);

De plus, vous n'avez pas besoin de size dans votre fonction de thread, car c'est la même chose que la limit , et la manière dont vous la calculez ne fonctionnera pas de toute façon puisque vous avez maintenant un pointeur au lieu d'un tableau. Votre limite de boucle dans fib_runner dépasse également la fin du tableau. La condition de sortie doit être i < size , pas i <= size .

vous devez passer une valeur de void * à pthread_exit qui est pthread_exit(( void * ) &fibSequence , une fois que cette fonction est appelée la valeur passée remplira le second argument de pthread_join , le second argument sera un pointeur sur un pointeur void ** il contiendra les valeurs passées à pthred_exit

Tous les threads exécutés dans un processus partagent le même espace d’adressage, les descripteurs de fichiers, les atsortingbuts liés à la stack et aux autres processus.

Les threads partagent la mémoire par définition, ils ne possèdent rien sauf la stack et les variables locales.

Si vous fibSequence[limit] global, tous les threads y auront access.

Vous pouvez également déclarer fibSequence[limit] sur la stack main et y passer le pointeur sur votre thread.

Pour transmettre plusieurs arguments, il est utile de les envelopper dans une structure. Les solutions ci-dessous emploient:

 struct arg_struct { int limit; int *ptrFib; }args;

Programme:

 #include  #include  #include  struct arg_struct { int limit; int *ptrFib; }args; void* fib_runner(void* arg) { struct arg_struct *a = (struct arg_struct *) arg; int size = a->limit; int * fibSequence = a->ptrFib; fibSequence[0] = 0; fibSequence[1] = 1; for (int i = 2; i <= size; i++){ fibSequence[i] = fibSequence[i-1] + fibSequence[i-2]; } pthread_exit(0); } int main(int argc, char **argv) { int limit; printf("Enter Number: "); scanf("%d", &limit); int fibSequence[limit]; struct arg_struct argF; argF.limit = limit; argF.ptrFib = fibSequence; pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_create(&tid, &attr, fib_runner, &argF); pthread_join(tid, NULL); for (int i = 0; i <= limit; i++){ printf("%d ", fibSequence[i]); } }

Sortie:

 Enter Number: 5 0 1 1 2 3 5

La solution avec la variable globale argF est bien sûr possible mais moins élégante.

 #include  #include  #include  struct arg_struct { int limit; int *ptrFib; }args; struct arg_struct argF; void* fib_runner() { int size = argF.limit; int * fibSequence = argF.ptrFib; fibSequence[0] = 0; fibSequence[1] = 1; for (int i = 2; i <= size; i++){ fibSequence[i] = fibSequence[i-1] + fibSequence[i-2]; } pthread_exit(0); } int main(int argc, char **argv) { int limit; printf("Enter Number: "); scanf("%d", &limit); int fibSequence[limit]; argF.limit = limit; argF.ptrFib = fibSequence; pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_create(&tid, &attr, fib_runner, NULL); pthread_join(tid, NULL); for (int i = 0; i <= limit; i++){ printf("%d ", fibSequence[i]); } }