C - la Création de threads n

La raison pour laquelle vous obtenez le même TID pour chaque thread, c'est que vous êtes d'appel syscall(SYS_gettid) depuis le thread principal à chaque fois, plutôt que de partir dans le nouveau thread que vous créez. Vous avez besoin de l'appeler à partir de l'intérieur de votre fonction de thread, et ensuite fournir un moyen de transmettre les informations de retour pour le thread principal si c'est nécessaire.

Comme un exemple d'une façon de le faire (certains vérification des erreurs omis):

Créer une structure pour tenir un mutex, l'état, le TID, et un drapeau pour indiquer quand le TID est valide.

struct s_threadId {
  pthread_mutex_t   mtx;    /* mutex & condition to allow main thread to
                               wait for the new thread to  set its TID */
  pthread_cond_t    cond;   /* '' */
  pid_t             id;     /* to hold new thread's TID */
  int               ready;  /* to indicate when 'id' is valid, in case
                               the condition wait gets interrupted */
};

Alors modifier la fonction de thread pour verrouiller, ensemble, et le signal (et déplacez-le de sorte qu'il est de déclaration est visible avant spawnThreads()):

void *foo(void *arg)
{
  struct s_threadId *thId = arg;

  /* Lock mutex... */
  pthread_mutex_lock(&thId->mtx);

  /* Get and save TID and ready flag.. */
  thId->id = syscall(SYS_gettid);
  thId->ready = 1;
  /* ..and signal main thread that we're ready */
  pthread_cond_signal(&thId->cond);

  /* ..then unlock when we're done. */
  pthread_mutex_unlock(&thId->mtx);

  /* ... */

  return NULL;
}

...et modifier votre spawnThreads fonction pour initialiser/nettoyage de la les membres de la structure et d'obtenir le TID une fois le fil définit:

void spawnThreads(unsigned int n)
{
  pthread_t thread; /* reused for each thread, since they run 1 at a time */

  /* struct to pass back TID */
  struct s_threadId threadId;
  pthread_cond_init(&threadId.cond, NULL);  /* init condition */
  pthread_mutex_init(&threadId.mtx, NULL);  /* init mutex */

  int i;
  for (i = 0; i < n; i++) {
    /* lock mutex *before* creating the thread, to make the new thread
       wait until we're ready before signaling us */
    pthread_mutex_lock(&threadId.mtx);

    /* clear ready flag before creating each thread */
    threadId.ready = 0;
    /* create threads and pass address of struct as argument */
    if (pthread_create(&thread, NULL, foo, &threadId)) {
      printf("pthread error!\n");
    } else {
      /* Wait on the condition until the ready flag is set */
      while (!threadId.ready) {
        pthread_cond_wait(&threadId.cond, &threadId.mtx);
      }
      /* Now we have the TID... */
      printf("%d %d\n", i, threadId.id);
      printf("I just created thread %d\n", i);
    }
    /* ..and unlock the mutex when done. */
    pthread_mutex_unlock(&threadId.mtx);

    pthread_join(thread, NULL);
  }

  /* When we're completely done with the struct we need to clean up the
     mutex and condition variable */
  pthread_mutex_destroy(&threadId.mtx);
  pthread_cond_destroy(&threadId.cond);
}

Ci-dessus, le mutex et l'état d'attente sont nécessaires pour s'assurer que le thread principal n'essayez pas d'imprimer le TID jusqu'à ce que le nouveau thread a eu la chance de le définir. Le thread principal débute un nouveau et puis attend, et le nouveau fil de signal quand c'est fait, le stockage de l'TID donc le thread principal peut continuer.