wenn man eine Klasse hat, die z.B. eine get-Funktion anbietet:

int getNumber() { return number; }

Wie macht man das dann Threadsafe? Mutex, etc. kommt hier ja nicht in Frage, da nach dem return kein Code mehr ausgeführt wird.
Ich müsste also über Referenzen gehen, oder?

void getNumber(int& num) { num = number; }

Nun müsste ich zwischen der Zuweisung eben Lock und Unlock aufrufen, ja?

void getNumber(int& num) { lock();  num = number; unlock(); }

Und darauf greife ich dann so zu:

int val;

myClass.getNumber(val);

Aber auf keinen(!) Fall so:

int& val

myClass.getNumber(val);

Habe ich das richtig verstanden oder handel ich mir damit Probleme ein?

Vielen Dank,
Paty

Ja, mach es mit Referenzen. So hab ich das auch in Erinnerung.
Aber ich frage mich, warum man reine Lesezugriffe synchronisieren muss?!

Das geht schonmal gar nicht.

Man könnte es auch so machen:

int getNumber()
{
	lock();
	int r = number;
	unlock();
	return r;
}

Wie man das am besten macht, würde mich auch mal interessieren.

int& val;

myClass.getNumber(val);

Das geht schonmal gar nicht.

Man könnte es auch so machen:

int getNumber()
{
	lock();
	int r = number;
	unlock();
	return r;
}

Aber r muß volatile sein sosnt wirds wegoptimiert

Aber r muß volatile sein sosnt wirds wegoptimiert

Also zumindest wenn man das WinAPI benutzt (Interlocked Funktionen, Critical Sections...), braucht man kein volatile. Es kümmert sich dann um die "memory barriers".

Aber r muß volatile sein sosnt wirds wegoptimiert

Wie "Check0r" schon schrieb: r muss nicht volatile sein.

Und normalerweise macht man sowas mit einer "scoped lock" Klasse, womit sich der Code zu folgendem reduziert:

int foo()
{
    my_scoped_lock<my_mutex_type> lock(mutex); // hier passiert "mutex.lock()"
    return number;
} // hier passiert "mutex.unlock()", also NACHDEM der returnwert kopiert wurde. und alles ist gut. wie durch magie :)