pthread_t pointeur en argument de pthread_create

Le premier argument de pthread_create est un pthread_t pointeur. Dans le programme bonjour ci-dessous, si le premier argument est un pointeur vers pthread_t (pthread_t*) au lieu d'un pthread_t (pthread_t) le programme se termine avec Segmentation fault...pourquoi?

Je ne me souviens pas de voir pthread_t* que le type déclaré de la premier argument de pthread_create.

Et le chapitre 2 de Butenhof du livre de la Programmation avec les Threads POSIX dit:

Pour créer un thread, vous devez déclarer une variable de type pthread_t [pas pthread_t*].

Mais selon la spécification le premier argument de pthread_create est un pointeur vers pthread_t, alors pourquoi l'erreur de segmentation?

Faute de Segmentation

pthread_t* thr;
pthread_create(thr, NULL, &hello, NULL);

Fonctionne OK

pthread_t thr;
pthread_t* pntr = &thr;
pthread_create(pntr, NULL, &hello, NULL);

bonjour programme:

#include <pthread.h>
#include <stdio.h>

void * 
hello(void *arg){
  printf("Hello\n");
  pthread_exit(NULL);
}

int 
main(int argc, char **argv){
  pthread_t thr = 1;
  pthread_create(&thr, NULL, &hello, NULL);



  pthread_join(thr, NULL);

  return 0;
}

pthread_create prototype:

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg);

Voir la différence entre défini et déclarée en stackoverflow.com/questions/1433204/...

OriginalL'auteur user454322 | 2012-12-19

c pointers pthreads

6
```
pthread_t* thr;
pthread_create(thr, NULL, &hello, NULL);
```
déclare un pointeur vers une pthread_t sans allocation de stockage pour elle. Lorsque vous appelez pthread_create, il va essayer d'écrire à *thr. C'est à un emplacement non défini et sera presque certainement un échec.
```
pthread_t thr;
pthread_t* pntr = &thr;
pthread_create(pntr, NULL, &hello, NULL);
```
fonctionne parce que vous avez déclarer de stockage (thr sur la pile) pour un pthread_t.

Noter que le second, le travail, la version simplifiée de ce qui est utilisé dans votre programme bonjour
```
pthread_t thr;
pthread_create(&thr, NULL, &hello, NULL);
```
...qui déclare un pthread_t sur la pile, puis passe un pointeur dans pthread_create.

Ohhh... C'est parce que & alloue de l'espace! Je ne pouvais donc pas une telle chose stupide. Merci
Notez que le second, le travail, la version peut être simplifiée dans le programme bonjour.
Oh, oui, je crains que je n'avais pas lu que loin sur la question. Je vais mettre à jour ma réponse

OriginalL'auteur simonc
3

C'est parce que si vous il suffit de déclarer un pointeur, vous ne pouvez pas vous attendre à point alloué, initialisation de la mémoire.

Lorsque vous déclarez une pthread_t il est attribué de son propre petit bloc de mémoire que vous pouvez ensuite obtenir l'adresse de la & de l'opérateur et de le passer à pthread_create.

La droite. Sans & le pointeur n'est pas initialisé. Je vous remercie.
Le & opérateur prend l'adresse de la pthread_t comme un pointeur de type pthread_t * et cela peut ensuite être utilisé pour appeler pthread_create. Il n'a pas d'initialiser le pointeur d'autant qu'il suffit de créer un pointeur valide pour une zone de mémoire allouée.
Peut-être que je n'étais pas clair. Avec l'initialisation du pointeur, je voulais prendre l'adresse de (point, par exemple, l'affectation de l'adresse de thr à pntr) la mémoire où la pthread_t se réfère. Remarque: juste entre pthread_t* pntr = &thr; et l'appel à pthread_create pntr vers la mémoire non (parce que thr n'a pas été initialisé).
pntr pointe vers alloués de mémoire, car il points de &thr; thr pourrait très bien être non initialisée, cependant.
Je vois votre point de vue. Puis pntr points de &thr qui à son tour les points de la mémoire non... droite?

OriginalL'auteur
0

Si vous voulez créer un peu de fil, vous pouvez utiliser le code ci-dessous:
```
pthread_t* thread_handles;
thread_handles = malloc(thread_count * sizeof(pthread_t));
for (thread = 0; thread < thread_count; thread++)
{
  pthread_create(&thread_handles[thread], NULL, threadFunc, (void*)input);
}
```
De cette façon, vous devez allouer de la mémoire pour vos poignées avant d'appeler pthread_create, tout comme lorsque vous voulez créer certains "struct" vous devez d'abord allouer de la mémoire pour eux.

OriginalL'auteur Mehdi

Vous devez vous connecter pour publier un commentaire.