Singleton mit double checked locking

opengl_noob

hi
Hab mich mit dem Singleton-Muster beschäftigt und möchte gern ein funktionierendes double checked locking. Der Vorteil ist ja, dass ich verzögerte Instantiierung mit Thread-Sicherheit habe (wenns funzt).
Nun hab ich mal diverse Quellen im Internet zu dem Thema gelesen.
Manche bezeichnen das DCL Singleton ja als Antipattern weil es soviele Probleme hervorrufen kann.

Jetzt hab ich hier mal Java-Code für ein DCL Singleton.

public class Singleton {
	private volatile static Singleton instance;
	private Singleton() {}
	public static getInstance() {
		if(instance == null) {
			synchronized(Singleton.class) {
				if(instance == null )
					instance = new Singleton();
			}
		}
		return instance;
	}
}

Das Besondere ist, dass instance durch das Schlüsselwort volatile gegen Compiler und CPU-reordering geschützt ist.
Und der synchronized-Block die Thread-Sicherheit garantiert.
Angeblich funzt der Code in Java für ein DCL Singleton einwandfrei (bei Wikipedia gibts ähnlichen Code, nur dass instance nicht volatile ist).

Jetzt hab ich mir mal entsprechenden Code für C++ gebastelt.

#include <afxmt.h>

CCriticalSection cs;

class Singleton{
private:
	static Singleton* volatile instance;	//volatile gegen Compiler und CPU-reordering
	Singleton() {}
public:
	static Singleton* getInstance()
	{
		if(instance == NULL)
		{			
			cs.Lock();		//Synchronisierungs-Block (für thread-safety)
				if(instance == 0)
					instance = new Singleton();
			cs.Unlock();			
		}
		return instance;
	}
};

Singleton* volatile Singleton::instance = new Singleton();

void main(){
	Singleton *singleton = Singleton::getInstance();
}

Bei Einstellungen -> C/C++ -> Code Generation musste ich auf Multithreaded wechseln damit das läuft.
Laut Microsoft garantiert Visual C++ 2005, dass volatile bei Variablen Compiler und CPU-reordering verhindert. Allerdings gibt es keine solche Garantie in früheren Versionen von Visual C++.
Da muss der Code wohl Memory-Barrieren enthalten.

Ich hab also den kritischen Abschnitt für thread-safety und volatile gegen Compiler und CPU-reordering. Dieser Code sollte doch bei Visual C++ 2005 jetzt einwandfrei funktionieren, oder?

HumeSikkins

Hi,
was Standard-C++ und das DCL-Singleton angeht, solltest du sicherstellen, dass du Scott Meyers' zweiteiligen Artikel gelesen hast:

http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004.pdf
bzw.
http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf

Dieser Code sollte doch bei Visual C++ 2005 jetzt einwandfrei funktionieren, oder?

Das kann man dir im VC-Forum sicher besser beantworten...

C++ Forumbot

Dieser Thread wurde von Moderator/in HumeSikkins aus dem Forum C++ in das Forum MFC (Visual C++) verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

hustbaer

Ja, unter Windows geht das, und ich sehe auch keinen Grund warum der VC 2005 dazwischenpfuschen sollte.
Allerdings ist IMHO diese Zeile falsch

Singleton* volatile Singleton::instance = new Singleton();

Wenn du das so schreibst kannst du dir gleich das ganze checken und locken sparen

BTW: auf x86 braucht man doch sowieso keine Memory-Barriers, oder irre ich mich da jetzt?

opengl_noob

Sorry, muss natürlich mit NULL initialisiert werden
Ja ich glaub auf x86 braucht man die nicht.