Und zwar will ich in verschiedenen Klassen Threads erzeugen.
Die Klassen sollen dabei vollautomatisch nachdem der Constructor ausgeführt wurde eine art
WorkerJob ausführen die im EndlessLoop laufen. Z.B. jede Sekunde die Zeit abfragen und dann bestimmte Ereignisse innerhalb der
Klasse ausführen. Dies ist vom Programmieren alles kein Problem für mich. Nur wenn ich ja einen Thread im EndlessLoop ausführen
bekomme ich das Problem das die Klasse nach dem Ausführen des Threads im EndlessLoop verharrt (was ja durch den EndlessLoop geschied).
mit "Thread Detach" kann ich das Problem ganz gut lösen. Ist der Ansatz überhaupt gut so? Kann ich mit detach überhaupt ein Mutex noch benutzen
um zugriff auf eine Variable aus mehren Threads abzusichern?

Ab da mal eine DummyClasse erzeugt und diese in der Main Instanziert.

* DummyClass.h

 */

#ifndef DUMMYCLASS_H_
#define DUMMYCLASS_H_

#include <iostream>
#include <string>
#include <thread>
#include <unistd.h>

namespace std {

class DummyClass {
public:
	DummyClass(const int id);
	virtual ~DummyClass();
private:
	int id;
	std::thread t1;
	void print(const std::string &text);
	void workerLoop();
};

}
#endif /* DUMMYCLASS_H_ */

/*
 * DummyClass.cpp
 */

#include "DummyClass.h"

namespace std {

DummyClass::DummyClass(const int id) {
	print ("created...");
	this->id = id;
	t1 = std::thread(&DummyClass::workerLoop,this);
	t1.detach();
}

DummyClass::~DummyClass() {
	print("destroyed...");
}

void DummyClass::print(const std::string &text){
	std::cout << std::string("[DummyClass ") << id << std::string("]>>\t") << text << std::endl;
}

void DummyClass::workerLoop(){
	print("start worker loop...");
	while(true){
		print("working...");
		sleep(1);
	}
}

} /* namespace std */

int main() {

	print("start...");

	DummyClass *dummy = new DummyClass(1);
	DummyClass *dummy2 = new DummyClass(2);

	print ("start main loop...");

	while (true) {
		sleep(1);
	}

	print("exit...");

	return 0;
}

Danke euch schonmal für die Antworten

Willkommen im C++-Forum!

das 'detach' löst den (physikalischen) Thread von dem Thread-Objekt ab. Damit bekommst Du zwar unmittelbar keinen Fehler mehr, aber der Thread läuft weiter und greift ggf. auf Daten eines bereits gelöschten Objekts zu.

Die saubere Lösung wäre, den Thread wirklich zu beenden. Also in Deinem Fall etwa so:

class DummyClass {
    // ...
private:
    bool running;
    int id;
    std::thread t1;
    // ...
};

DummyClass::DummyClass(const int id) 
    : running( true )
    , id( id )
    , t1( &DummyClass::workerLoop, this )
{
    print ("created...");
}

DummyClass::~DummyClass() {
    running = false;
    print("before join...");
    t1.join();
    print("destroyed...");
}

void DummyClass::workerLoop(){
    print("start worker loop...");
    while( running ){
        print("working...");
        sleep(1);
    }
}

Gruß
Werner

Werner Salomon schrieb:

class DummyClass {
    // ...
private:
    bool running;
    int id;
    std::thread t1;
    // ...
};

Es müsste

std::atomic<bool> running;

heißen, ansonsten sieht der Workerthread den geänderten Wert möglicherweise nicht.

Meine Frage ist es nun wie kann ich in einer Klasse die Dauerhaft instanziert ist einen Endlessloop laufen lassen der dann bestimmte Dinge immer wieder abarbeitet ohne das Speicherzugrifffehler auftauchen können?

Es kann auch vorkommen das ich mehre Endlessloops benötige.

Oder müsste ich dann ggf eine Singleton Klasse machen die dann aus der Main immer eine Art UpdateMethode besitzt die ich dann in der Main polle?

Oder ist es sinnvoll ohne Endless Loop zu arbeiten und einfach immer wieder einen Thread wenn dieser beendet ist neu zu erzeugen?

kann ich in einer Klasse die Dauerhaft instanziert ist einen Endlessloop laufen lassen der dann bestimmte Dinge immer wieder abarbeitet ohne das Speicherzugrifffehler auftauchen können?

Theorethisch ja, bis die klasse zerstört wird, bzw das programm beendet wird.
Alle ressourcen die der Thread nutzt muessen natürlich so lange gültig bleiben.

Bis dahin ists recht einfach ....

DIe Frage ist eher, wie beendet man sowas sauber, ohne das programm immer abschiessen zu muessen ?

Also MainThread erzeugt Worker Threads
Worker Threads arbeiten kontinuierlich

1. Was macht der MainThread nachdem die Threads erzeugt wurden ?
2. Wie wird das Program beendet ?

Das musst du wissen !

Meistens hat man im Zusammenhang mit sowas eh ein EventHandling, aka Eventloop, wenn das beenden von irgendwas initiiert wird, was nicht in den Worker threads passiert / abgefangen wird ...

Oder ist es sinnvoll ohne Endless Loop zu arbeiten und einfach immer wieder einen Thread wenn dieser beendet ist neu zu erzeugen?

Nö, erzeugen und zerstören kostet Performance ... wiederverwenden macht mehr sinn. Am besten mit Threadpools, um die Anzahl der laufenden threads zu kontrollieren ...

Ciao ...

cpp_Freak schrieb:

Meine Frage ist es nun wie kann ich in einer Klasse die Dauerhaft instanziert ist einen Endlessloop laufen lassen der dann bestimmte Dinge immer wieder abarbeitet ohne das Speicherzugrifffehler auftauchen können?

So pauschal kann man das nicht beantworten. Es kommt da wirklich auf den Einzelfall an. Ansonsten kann ich Dir das Buch
C++ Concurrency in Action | ISBN: 9781933988771 'C++ Concurrency in Action' empfehlen (ISBN = 9781933988771).
Dort ist auf mehr als 500 Seiten beschrieben, wie man so was macht.

Am besten Du nennst uns ganz konkret ein kleines Beispiel, was in so einem WorkerThread passieren soll und welche Schnittstellen zum main-Thread Deiner Meinung nach dafür notwendig sind.

Gruß
Werner

-Ich habe zb 3 Klassen und eine Main.
-Es geht darum das 2 Klassen als Module ansehe die dann nur in der Main Instanziert werden und dann über ihren Konstruktor initalisiert werden und sich in den Klassen dann Endless Threads auch starten.
-Zb soll ein Modul(Klasse) einen bestimmten Sensorwert abfragen und das ergebniss Parsen.
-Die geparsten Daten werden dann an eine Public Methode einer Klasse die in dieser Instanziert wurde weitergegeben.
-Die Klasse mit der Public Methode hat einen eigenen Worker Thread der dann bestimmte Sachen aus einer Vector Liste zu bestimmten urzeiten die Sensor Daten vergleicht usw....
-Im klar Text sehe ich die Klassen als Module an die ich einfach instanziere und dann eigenständig laufen.
-OOP und so sind mir seit Jahren geläufig
-Es geht halt nur darum das ja 2 Threads oder mehrer vl auf ein Objekt zb Liste zugreifen und da ist es ja wichtig diese durch Mutex zu schützen. Nur geht das ja nicht mit Detach oder doch?
-Bin mit dem Threading in C++ Klassen noch ein wenig neu

Ok - versuche bitte das ganze noch einmal aus der Sicht eines Anwenders zu beschreiben. Mal angenommen, Dein Programm läuft auf einem PC oder Kleincomputer. Der User hat keine Ahnung von den internen Programmstrukturen. Er weiß, dass da zwei Sensoren angeschlossen sind, z.B. ein Druck- und ein Temperatursensor.

Wie würde so ein Anwender Dein Programm beschreiben? Was kann er damit machen? Was bringt dem User diese Liste und der Vergleich mit den Sensordaten?

Gruß
Werner