QThreads - Verständnisproblem

donglebob

Hi,

mir war von pthreads eigentlich klar, dass threads gemeinsamen speicher haben.
Bei Qthreads kann ich diese Eigenschaft nicht wiederfinden.

Kann mir dies jemand zeigen?

thread t1,t2;
	t1.start();
        t2.start();

	1)std::cout << "nummer before : " << t1.get()<<std::endl;
	2)t1.set(5);
	3)std::cout << "nummer after : " << t1.get()<<std::endl;

       	4)std::cout << "nummer before : " << t2.get()<<std::endl;
	5)t2.set(10);
	6)std::cout << "nummer after : " << t2.get()<<std::endl;

thread ist eine von QThread abgeleitete Klasse.
mit den Set und Get Methoden setze ich eine private Variable der thread-klasse.

Bei der Ausgabe 4) hätte ich als Rückgabewert von t2.get "5" erwartet.
So ist es aber nicht...

Warum nicht? Speicher wird doch geteilt?

Was müsste ich ändern um diese Eigenschaft zu Gesicht zu bekommen?

DrGreenthumb

du verwechselst hier threads mit deinen QThread-Objekten. Die beiden Objekte haben natürlich ihre eigenen Daten.

donglebob schrieb:

Was müsste ich ändern um diese Eigenschaft zu Gesicht zu bekommen?

die Daten in der Klasse statisch machen, das hat mit Threads erstmal nichts zu tun.

donglebob

ok danke.

habe ich es richtig verstanden? nur durch die "Statisch-Machung" meiner Klassen-variablen erreiche ich diesen konkurrierenden Zugriff auf diese?

oder gibt es da noch einen anderen Weg?

Noch eine andere Frage:

Ich habe zwei Threads (erzeugt durch unterschiedliche Thread/Klassen-Instanzen).
Die beiden haben unterschiedliche Aufgaben und werden an unterschiedlichen Stellen erzeugt/instanziert. Irgendwann will der eine Thread an die gesammelten Daten des anderen Threads.

Wie würdet ihr den Datenaustausch umsetzen? (mit QT mitteln)
Die Daten liegen in der ersten Thread-Instanz in einer Liste.
Der Inhalt soll bei Bedarf vom zweiten Thread abgeholt werden.

EDIT:
Ein QThread-Thread teilt seine Daten nur dann, wenn ich sie static mache.
Im Urzustand von Qthread wird nichts geteilt.

Du verwechselst da was. Threads sind für die Nebenläufigkeit da, das heißt, dafür da, dass zwei Aufgaben parallel abgearbeitet werden.

Willst du mehrere Threads miteinander kommunizieren lassen, musst du sie schon in die gleichen Variablen schreiben lassen. Aber DAS DARFST DU NICHT machen. Diese Zugriffe müssen geschützt ablaufen. Sonst gibt es große Probleme, wenn zwei Threads gleichzeitig auf eine Variable drauf zugreifen.

Ich würde an deiner Stelle mich nochmal genauer mit C++ auseinandersetzen, denn das mit den Variablen sind eigentlich Sachen, die bekannt sein sollten, bevor(!) du dich mit anderen Sachen auseinandersetzt.

donglebob

Hi,

mir ist schon klar, dass Thread für die Nebenläufigkeit da sind.
Dafür will ich sie auch nutzen.

Dass man gemeinsamen Speicher einsetzt und dass man es auch schützen muss auch. Mutex Semaphore usw...

Muss ich denn unbedingt eine gemeinsame Variable verwenden um Daten auszutauschen?

Ich erläutere mal mein Modell:

Master ist von QThread abgeleitet
Worker ist von QThread abgeleitet
( = unterschiedliche Klassen)

Irgendwo im Programm sammle ich Daten in einer *Liste*.
Nun wurde an einer anderen Stelle im Programm eine Instanz von der Master-Klasse erzeugt. Nach dieser Instanzierung lasse ich mit start() den Master-Thread laufen.

Der Master-Thread ist dazu da, um in gewissen Abständen die *Liste* zu überprüfen, und falls Daten vorliegen abzuholen.
Hier nun das erste Problem. Wie holt mein Master-Thread am besten diese Daten ab?
Einfach get/set methoden?

Der Master-Thread hat nun die Daten erhalten.
Die Worker-Threads werden zur Laufzeit erzeugt. Hier bin ich noch nicht sicher wo ich die Worker-Threads erzeugen soll. Eventuell durch den Master-Thread (in der Master-Thread-Instanz dynamisch instanziert)

Nun soll der Master-Thread, die soeben erhaltenen Daten aus der *Liste* an die Worker verteilen.
Hier muss auch ein Datenaustausch stattfinden.
Wie sollte das am besten gemacht werden?

Hoffe mal ich konnte meine Vorgehensweise einigermaßen gut erläutern.

donglebob schrieb:

Muss ich denn unbedingt eine gemeinsame Variable verwenden um Daten auszutauschen?

Gegenfrage: Wie willst du es denn sonst machen?

Folgendes würde ich vorschlagen. Du willst Aufgaben verteilen. Dafür nimmst du eine Queue. Diese Queue wird mit Mutexen abgesichert, so dass jeder Thread darauf zugreifen kann. Jeder Thread liest jetzt aus der Queue, erledigt die erhaltene Aufgabe und liest wieder aus der Queue. Dafür muss natürlich jedes Thread-Objekt einen Pointer auf die entsprechende Queue speichern. Alles über Mutexe geschützt. Ist die Queue leer, kannst du einen Thread solange "einschläfern", bis neue Daten in der Queue sind. Siehe dafür "Conditionals".

Btw.: Deine Beschreibungen sind mir zu wage. Ich verstehe nicht so ganz dein Problem. Darum eine etwas allgemeine Antwort.

donglebob

Gegenfrage: Wie willst du es denn sonst machen?

meine liste mit den Daten ist in objekt A gespeichert.
wenn ich nun den ptr an einen master-thread weiterreiche, kann es mit A_ptr->getList() an die Daten rankommen.
so hätte ich es realisiert.
(Das wäre die Vorgehensweise für den Master-Thread, der die Daten von A abholen muss)

Die Verteilung von Master-Thread an die Worker-Threads könnte ich so machen, wie du es vorgeschlagen hast. Mit der Queue.

Nun ist da aber folgendes Problem. Bei deiner Beschreibung darf jeder Thread von dieser Queue lesen.
Das darf ich nicht.
Hier der Grund:
Jeder Worker-Thread, repräsentiert einen Hardware-Sensor in der Realität.
D.h. die Daten von Sensor 1 sollte an Worker-Thread 1 gehen und nur dieser sollte die Daten von Sensor 1 zu Gesicht bekommen.

Aus diesem Grund muss beim verteilen aus der Queue darauf geachtet werden, wer es bekommt.

Dann kriegt jedes Thread-Objekt halt eine Queue, die mit Mutexen und Conditionals abgesichert ist und welche die Aufgaben für einen bestimmten Thread enthält. Du musst dann natürlich irgendwo, z.B. in deinem Masterthread-Objekt oder sonst wo, eine Liste mit allen Thread-Objekten haben, damit du die Daten entsprechend verteilen kannst.

donglebob

Hi,

Danke. genau so!