Multi-Threads innerhalb von Multi-Klassen

Question

Ich möchte zwei Threads ausführen, einen für jede Klasse, die ich habe. Aber ich möchte, dass sie unabhängig sind. Zum Beispiel habe ich so etwas:

class A 
{ 
    pthread_t threadA; 

    void runThreadA() { pthread_create(... arguments_here ...)}; 
} 

class B 
{ 
    pthread_t threadB; 

    void runThreadB() { pthread_create(... arguments_here ...)}; 
} 

Derzeit ich erstellen und ausführen, um die zwei Threads intern für jede Klasse, aber mein Haupt ist wie folgt:

main() 
{ 
    A.runThreadA(); 
    B.runThreadB(); 

    pthread_join(threadA, NULL); 
    pthread_join(threadB, NULL); 

    return 0; 
} 

Wie kann ich die beiden Fäden verbinden auch intern, wodurch die zwei Threads zwei parallel laufen?

Hoffnung I verständlich bin .. Danke

Answer 1

Ich werde dies als eine Antwort verlassen, weil ich noch nicht über Privilegien zu kommentieren, aber ich werde mein Bestes geben. Ich werde das interpretieren, wenn Sie sagen, Threads intern verbinden, dass Sie innerhalb der Klasse und automatisch bedeuten, ohne die zusätzlichen Join-Zeilen in der Hauptfunktion schreiben zu müssen. Kurz gesagt, die Antwort ist ja. Sie können Join innerhalb einer Klasse aufrufen, aber aus dem folgenden Grund ist es etwas ineffektiv, dies zu tun.

Lässt dieses Beispiel betrachten (ich werde std :: Thread verwenden, weil ich damit bequemer bin, aber Pthread wird sehr ähnlich funktionieren):

class1 
{ 
    std::thread *t1; 
    void DoWork1(); 
    void CreateThread1() { 
     t1= new std::thread(&class1::DoWork1, this) 
     JoinThread1(); 
    } 
    void JoinThread1(){ 
     if (t1.joinable()) { 
      t1.join(); 
     } 
    } 

}; 

class2 
{ 
    std::thread *t2; 
    void DoWork2(); 
    void CreateThread2() { 
     t2= new std::thread(&class2::DoWork2, this) 
     JoinThread2(); 
    } 
    void JoinThread2(){ 
     if (t2.joinable()) { 
      t2.join(); 
     } 
    } 
}; 

Jetzt haben wir theoretisch abgeschlossen Dieses Ziel, dass jedes Mal, wenn wir Class1::CreateThread() anrufen, wird es automatisch auch ohne den zusätzlichen Bedarf dieser join() Aufruf im Haupt-Thread beitreten. Außer müssen wir uns daran erinnern, dass join() eine Sperrfunktion ist. Also, wenn wir die Class1::CreateThread() in der main() aufrufen, dann wird es blockieren, bis der Thread beendet und verbunden ist und nur dann in der Lage wäre, Class2::CreateThread() aufrufen. Wenn wir diese Methode ausprobiert haben, sollte es offensichtlich sein, dass die Threads nicht parallel laufen und es keinen Vorteil hat, überhaupt Threads zu verwenden.

Es gibt ein Argument für den Aufruf join() im Destruktor der Klasse, aber Sie müssten immer noch den Destruktor irgendwo aufrufen, so dass wir immer noch nicht die gleiche Automatisierung erhalten, die Sie suchen.

Dieses Beispiel war äußerst einfach, aber es zeigt hoffentlich etwas Wichtiges. Unabhängig davon, wo in der Klasse Sie diese Funktionalität implementieren, um dem Thread beizutreten, wird es Sie entweder daran hindern, Ihren Haupt-Thread zu verwenden, um andere Dinge zu tun, wie zum Beispiel einen zweiten Thread zu erstellen (was viel von dem Zweck von Threads vereitelt) Um diese Memberfunktion aufzurufen, die den Thread trotzdem manuell von Ihrem main verbindet, würde der einzige Unterschied darin bestehen, dass es sich um eine Memberfunktion der Klasse handelt und nicht so, wie Sie sie im obigen Beispiel haben.

TLDR Aufgrund der Tatsache, dass join() eine Sperrfunktion ist, wird sie aufgerufen werden muß „von Hand“, um sicherzustellen, dass Sie einen Nutzen aus dem Thread zu bekommen.