Wie kann ich warten, bis alle pthreads abgeschlossen sind?

Ich möchte nur, dass mein Hauptthread darauf wartet, dass alle meine (p) Threads abgeschlossen sind, bevor er beendet wird.

Die Threads kommen und gehen aus verschiedenen Gründen, und ich möchte sie wirklich nicht alle im Auge behalten – ich möchte nur wissen, wann sie alle weg sind.

wait() tut dies für untergeordnete Prozesse und gibt ECHILD zurück, wenn keine untergeordneten Elemente mehr vorhanden sind, aber wait funktioniert nicht (scheint mit) (p)threads.

Ich möchte mir wirklich nicht die Mühe machen, eine Liste aller ausstehenden Threads zu führen (wie sie kommen und gehen) und dann pthread_join für jeden aufrufen zu müssen.

Gibt es dafür einen Quick-and-Dirty-Weg?

Soll Ihr Haupt-Thread etwas Bestimmtes tun, nachdem alle Threads abgeschlossen sind?

Wenn nicht, kannst du deinen Hauptthread einfach aufrufen pthread_exit() Anstatt zurückzukehren (oder anzurufen exit()).

Wenn main() gibt es implizit zurück (oder verhält sich so, als ob es angerufen hätte) exit(), wodurch der Vorgang beendet wird. jedoch, wenn main() Anrufe pthread_exit() Anstatt zurückzukehren, dieser implizite Aufruf an exit() tritt nicht auf und der Prozess wird nicht sofort beendet – er endet, wenn alle Threads beendet wurden.

• http://pubs.opengroup.org/onlinepubs/007908799/xsh/pthread_exit.html

Zu viel Quick-n-Dirtier geht nicht.

Hier ist ein kleines Beispielprogramm, mit dem Sie den Unterschied sehen können. Passieren -DUSE_PTHREAD_EXIT an den Compiler, um zu sehen, wie der Prozess wartet, bis alle Threads beendet sind. Kompilieren Sie, ohne dass dieses Makro definiert ist, um die Prozessstopp-Threads in ihren Spuren zu sehen.

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

static
void sleep(int ms)
{
    struct timespec waittime;

    waittime.tv_sec = (ms / 1000);
    ms = ms % 1000;
    waittime.tv_nsec = ms * 1000 * 1000;

    nanosleep( &waittime, NULL);
}

void* threadfunc( void* c)
{
    int id = (int) c;
    int i = 0;

    for (i = 0 ; i < 12; ++i) {
        printf( "thread %d, iteration %d\n", id, i);
        sleep(10);
    }

    return 0;
}


int main()
{
    int i = 4;

    for (; i; --i) {
        pthread_t* tcb = malloc( sizeof(*tcb));

        pthread_create( tcb, NULL, threadfunc, (void*) i);
    }

    sleep(40);

#ifdef USE_PTHREAD_EXIT
    pthread_exit(0);
#endif

    return 0;
}

Der richtige Weg ist, alle Ihre pthread_ids im Auge zu behalten, aber Sie haben nach einem schnellen und schmutzigen Weg gefragt, also hier ist es. Grundsätzlich:

• Behalten Sie einfach die Gesamtzahl der laufenden Threads bei,
• Erhöhen Sie es in der Hauptschleife, bevor Sie pthread_create aufrufen.
• Dekrementieren Sie die Thread-Zählung, wenn jeder Thread endet.
• Schlafen Sie dann am Ende des Hauptprozesses, bis die Zählung auf 0 zurückkehrt.

.

volatile int running_threads = 0;
pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;

void * threadStart()
{
   // do the thread work
   pthread_mutex_lock(&running_mutex);
   running_threads--;
   pthread_mutex_unlock(&running_mutex);
}

int main()
{
  for (i = 0; i < num_threads;i++)
  {
     pthread_mutex_lock(&running_mutex);
     running_threads++;
     pthread_mutex_unlock(&running_mutex);
     // launch thread

  }

  while (running_threads > 0)
  {
     sleep(1);
  }
}

Wenn Sie Ihre Fäden nicht im Auge behalten möchten, können Sie die Fäden lösen, damit Sie sich nicht um sie kümmern müssen, aber um zu sagen, wann sie fertig sind, müssen Sie etwas weiter gehen.

Ein Trick wäre, eine Liste (verknüpfte Liste, Array, was auch immer) der Status der Threads zu führen. Wenn ein Thread startet, setzt er seinen Status im Array auf etwas wie THREAD_STATUS_RUNNING und kurz bevor er endet, aktualisiert er seinen Status auf etwas wie THREAD_STATUS_STOPPED. Wenn Sie dann überprüfen möchten, ob alle Threads gestoppt wurden, können Sie einfach über dieses Array iterieren und alle Status überprüfen.

Vergessen Sie jedoch nicht, dass Sie in diesem Fall den Zugriff auf das Array so steuern müssen, dass nur ein Thread darauf zugreifen kann (read und schreiben) es auf einmal, also müssen Sie einen Mutex darauf verwenden.

Sie könnten eine Liste aller Ihrer Thread-IDs führen und dann pthread_join für jede ausführen. Natürlich benötigen Sie einen Mutex, um den Zugriff auf die Thread-ID-Liste zu steuern. Sie benötigen auch eine Art Liste, die während der Iteration geändert werden kann, vielleicht ein std::set?

int main() {
   pthread_mutex_lock(&mutex);

   void *data;
   for(threadId in threadIdList) {
      pthread_mutex_unlock(&mutex);
      pthread_join(threadId, &data);
      pthread_mutex_lock(&mutex);
   }

   printf("All threads completed.\n");
}

// called by any thread to create another
void CreateThread()
{
   pthread_t id;

   pthread_mutex_lock(&mutex);
   pthread_create(&id, NULL, ThreadInit, &id); // pass the id so the thread can use it with to remove itself
   threadIdList.add(id);
   pthread_mutex_unlock(&mutex);  
}

// called by each thread before it dies
void RemoveThread(pthread_t& id)
{
   pthread_mutex_lock(&mutex);
   threadIdList.remove(id);
   pthread_mutex_unlock(&mutex);
}

Danke an alle für die tollen Antworten! Es wurde viel über die Verwendung von Speicherbarrieren usw. gesprochen – also dachte ich, ich würde eine Antwort posten, die richtig zeigt, dass sie dafür verwendet werden.

#define NUM_THREADS 5

unsigned int thread_count;
void *threadfunc(void *arg) {
  printf("Thread %p running\n",arg);
  sleep(3);
  printf("Thread %p exiting\n",arg);
  __sync_fetch_and_sub(&thread_count,1);
  return 0L;
}

int main() {
  int i;
  pthread_t thread[NUM_THREADS];

  thread_count=NUM_THREADS;
  for (i=0;i<NUM_THREADS;i++) {
    pthread_create(&thread[i],0L,threadfunc,&thread[i]);
  }

  do {
    __sync_synchronize();
  } while (thread_count);
  printf("All threads done\n");
}

Beachten Sie, dass die __sync-Makros “nicht standardmäßige” GCC-interne Makros sind. LLVM unterstützt diese auch – aber wenn Sie einen anderen Compiler verwenden, müssen Sie möglicherweise etwas anderes tun.

Eine weitere wichtige Sache, die Sie beachten sollten, ist: Warum sollten Sie einen ganzen Kern verbrennen oder “die Hälfte” einer CPU verschwenden, die sich in einer engen Abfrageschleife dreht und nur darauf wartet, dass andere fertig werden – wenn Sie es einfach zum Laufen bringen könnten? Der folgende Mod verwendet den anfänglichen Thread, um einen der Worker auszuführen, und wartet dann, bis die anderen fertig sind:

  thread_count=NUM_THREADS;
  for (i=1;i<NUM_THREADS;i++) {
    pthread_create(&thread[i],0L,threadfunc,&thread[i]);
  }

  threadfunc(&thread[0]);

  do {
    __sync_synchronize();
  } while (thread_count);
  printf("All threads done\n");
}

Beachten Sie, dass wir beginnen, die Threads bei „1“ statt bei „0“ zu erstellen, dann direkt „thread 0“ inline ausführen und darauf warten, dass alle Threads abgeschlossen werden, nachdem es fertig ist. Wir übergeben &thread[0] aus Gründen der Konsistenz (auch wenn es hier bedeutungslos ist), obwohl Sie in Wirklichkeit wahrscheinlich Ihre eigenen Variablen/Kontext übergeben würden.