Wie kann ich zwischen Threads kommunizieren?

Question

Wie kann ich in C++ Threads erstellen und zwischen dem Hauptthread und einem anderen Thread kommunizieren?

Für einige Code-Beispiele wären wir dankbar.

Answer 1

Threads teilen sich Variablen mit ihrem Bereich, deshalb sind Mutex-Sperren so wichtig.

Sie können also ganz einfach kommunizieren, indem Sie eine gemeinsame Variable für beide Threads bearbeiten:

#include <iostream>
#include <pthread.h> 
main()  {
    pthread_t f2_thread, f1_thread; 
    void *f2(), *f1();
    int i1;
    i1 = 1;
    pthread_create(&f1_thread,NULL,f1,&i1);
    pthread_create(&f2_thread,NULL,f2,&i1);
    pthread_join(f1_thread,NULL);
    pthread_join(f2_thread,NULL);
}
void *f1(int *x){
  std::cout << *x << std::endl;
}
void *f2(int *x){
  sleep(1)
  std::cout << ++(*x) << std::endl;
}

Dies sollte ausgedruckt werden:

1
2

Und die Variable i1 wurde zwischen den Threads geteilt. Dies ist eine Form der Kommunikation, Sie können Klassen, Strukturen, Strings, alles was Sie wollen, gemeinsam nutzen.

HINWEIS: Dieser Code wird mit ziemlicher Sicherheit einen Thread-Race verursachen. Dies ist nur ein Beispiel. Sie sollten immer Synchronisierung und Thread-sichere Praktiken verwenden, wenn Sie Speicher zwischen Threads teilen.

Answer 2

Bei der Threaderstellung liegt die Antwort auf der Hand (ich denke, das ist sie), entweder std::thread wenn Sie C++11 oder boost::thread sonst, aber im Falle von Message Passing hängt es von Ihrem Problem und Ihrem Programmierstil ab.
Als Allzwecklösung bevorzuge ich die Verwendung von boost::asio::io_service es ist sehr flexibel und man kann jede Art von Funktion oder Funktionsobjekt zur Ausführung im Kontext eines anderen Threads posten, mit dieser Technik braucht man keinen Mutex oder ähnliches und man kann auch Threads zu Konsumenten und Produzenten gruppieren und viele andere nützliche Funktionen sind verfügbar.

Answer 3

Okay, ich werde Ihnen das Einfachste sagen, was ich weiß: _beginthread

• Sie müssen Folgendes einschließen process.h damit dies funktioniert.
• Es muss eine Funktion vorhanden sein, die mit einem Gewinde versehen werden soll.
• Der Funktionsparameter inlet muss (void *) sein.
• Funktion sollte eine _endthread() wenn sie beendet werden muss.

In dem folgenden Programm konkurrieren zwei Threads darum, den Pi-Wert zu finden. Wenn einer von ihnen den Wert pi findet, teilt er dem anderen Thread mit, dass er enden soll. Auch in main() wird ausgegeben, welcher Thread den Wert pi gefunden hat. Der dritte Thread wartet nur darauf, dass einer der anderen Threads beendet wird.

      #include<process.h>
      #include<windows.h> //for the Sleep()
      #include<stdio.h>
      volatile boolean found=false;
      volatile int who=0;

      void find_pi_core1(void * iterations)
      {

          int * ite=(int *)iterations;
          for(int i=0;i<ite;i++)
          {
              //a sample of Monte-Carlo method here to find pi 
              //gets pi with more precision with additional iterations
               if(found) _endthread();
          }
          found=true;who=1;
          _endthread();    

       }

       void find_pi_core2(void * iterations)
       {

           int * ite=(int *)iterations;
           for(int i=0;i<ite;i++)
           {
                //a sample of Monte-Carlo method here to find pi 
                //gets pi with more precision with additional iterations
                 if(found) _endthread();
           }
           found=true;who=2;
          _endthread();
      }

       void printscreeN(void * dummy)
       {

          while(!found)
          {
              Sleep(30);      //if dont sleep, it gets a lot of cpu power
          }
          printf(" found! \n" );
          _endthread();
      }

      int main()
      {

                      Function name
                          ^       Stack size
                          |          ^           Function parameter
                          |          |             ^
          _beginthread(find_pi_core1,0,(void *) 3000000);
          _beginthread(find_pi_core2,0,(void *) 2500000);
          _beginthread(printscreeN,0,(void *)0);
          Sleep(3000);
          if(found)
          { 
               printf("pi has been found! core-%d has found pi first ",who);
          }
          else
          {printf("pi has not been bound!");}
          return 0;
      }

Answer 4

Die Erstellung von Threads ist abhängig vom Betriebssystem.

unter Linux können Sie die pthread-Bibliotheksfunktion pthread_create verwenden, um Threads zu erstellen, und pthread_join, um auf das Ende des Threads zu warten.

Unter Windows können Sie mit der Windows-API-Funktion CreateThread() Threads erstellen und mit der Funktion WaitForSingleObject() warten, bis der Thread beendet ist.