Singleton Beispiele (Design Pattern) - Versionsgeschichte

L-ectron-X: /* Implementierung in Perl */

2018-03-08T19:29:43Z

Implementierung in Perl

← Nächstältere Version		Version vom 8. März 2018, 19:29 Uhr
Zeile 396:		Zeile 396:
	Hier wird $instance bereits bei der Initialisierung von Singleton angelegt. Durch das :shared wird das Beispiel außerdem thead-safe.		Hier wird $instance bereits bei der Initialisierung von Singleton angelegt. Durch das :shared wird das Beispiel außerdem thead-safe.

	<~~code~~=perl>		<syntaxhighlight lang="perl">
	package Singleton;		package Singleton;

Zeile 407:		Zeile 407:
	42;		42;

	</~~code=perl~~>		</syntaxhighlight>

	[[Kategorie:Design Pattern]]		[[Kategorie:Design Pattern]]
	{{Wikipedia\|Seite=Einzelstück_(Entwurfsmuster)}}		{{Wikipedia\|Seite=Einzelstück_(Entwurfsmuster)}}

L-ectron-X: /* Implementierung in Perl */

2018-03-08T19:27:20Z

Implementierung in Perl

← Nächstältere Version		Version vom 8. März 2018, 19:27 Uhr
Zeile 263:		Zeile 263:
	Die Methode instance gibt $instance zurück, bzw. initialisiert es vorher noch, wenn dies noch nicht geschehen ist.		Die Methode instance gibt $instance zurück, bzw. initialisiert es vorher noch, wenn dies noch nicht geschehen ist.

	<~~code~~=perl>		<syntaxhighlight lang="perl">
	package My::Singleton;		package My::Singleton;

Zeile 271:		Zeile 271:

	sub instance() {		sub instance() {
	return $instance or $instance = bless {};		return $instance or $instance = bless {};
	}		}

	42;		42;
	</~~code=perl~~>		</syntaxhighlight>


	Dies kann dann mit dem folgenden Code genutzt werden:		Dies kann dann mit dem folgenden Code genutzt werden:

	<~~code~~=perl>		<syntaxhighlight lang="perl">
	use My::Singleton;		use My::Singleton;

Zeile 286:		Zeile 286:
	my $zwei = My::Singleton->instance; # die gleiche Instanz		my $zwei = My::Singleton->instance; # die gleiche Instanz

	</~~code=perl~~>		</syntaxhighlight>

	===== Mit [[CPAN\|CPAN]]-Modul =====		===== Mit [[CPAN\|CPAN]]-Modul =====

L-ectron-X: /* Implementierung in Python (ab Version 2.2) */

2018-03-08T19:26:16Z

Implementierung in Python (ab Version 2.2)

← Nächstältere Version		Version vom 8. März 2018, 19:26 Uhr
Zeile 243:		Zeile 243:

	==== Implementierung in [[Python (Programmiersprache)\|Python]] (ab Version 2.2) ====		==== Implementierung in [[Python (Programmiersprache)\|Python]] (ab Version 2.2) ====
	<syntaxhighlight lang="~~phyton~~">		<syntaxhighlight lang="python">
	class Singleton(object):		class Singleton(object):
	def __new__(type, *args):		def __new__(type, *args):

L-ectron-X: /* Implementierung in Python (ab Version 2.2) */

2018-03-08T19:25:30Z

Implementierung in Python (ab Version 2.2)

← Nächstältere Version		Version vom 8. März 2018, 19:25 Uhr
Zeile 243:		Zeile 243:

	==== Implementierung in [[Python (Programmiersprache)\|Python]] (ab Version 2.2) ====		==== Implementierung in [[Python (Programmiersprache)\|Python]] (ab Version 2.2) ====
	<~~code~~=~~python~~>		<syntaxhighlight lang="phyton">
	class Singleton(object):		class Singleton(object):
	def __new__(type, *args):		def __new__(type, *args):
Zeile 257:		Zeile 257:
	# Einmalige Dinge wie z. B. die Initialisierung von Klassenvariablen müssen also in diesen Block.		# Einmalige Dinge wie z. B. die Initialisierung von Klassenvariablen müssen also in diesen Block.
	self._ready = True		self._ready = True
	</~~code=python~~>		</syntaxhighlight>

	==== Implementierung in [[Perl (Programmiersprache)\|Perl]] ====		==== Implementierung in [[Perl (Programmiersprache)\|Perl]] ====

L-ectron-X: /* Implementierung in Actionscript (Version 2) */

2018-03-08T19:20:50Z

Implementierung in Actionscript (Version 2)

← Nächstältere Version		Version vom 8. März 2018, 19:20 Uhr
Zeile 181:		Zeile 181:
	==== Implementierung in [[Actionscript\|Actionscript]] (Version 2) ====		==== Implementierung in [[Actionscript\|Actionscript]] (Version 2) ====

	<~~code~~=actionscript>		<syntaxhighlight lang="actionscript">


Zeile 213:		Zeile 213:
	*/		*/

			</syntaxhighlight>
	</~~code=actionscript~~>

	==== Implementierung in [[PHP]] (ab Version 5) ====		==== Implementierung in [[PHP]] (ab Version 5) ====

L-ectron-X am 8. März 2018 um 19:18 Uhr

2018-03-08T19:18:40Z

← Nächstältere Version		Version vom 8. März 2018, 19:18 Uhr
Zeile 93:		Zeile 93:

	Erste Methode: hat den Vorteil, dass bei Programmende das Objekt automatisch zerstört wird (und der Destruktor aufgerufen wird). Darüber, wann das passiert, hat man aber keine Kontrolle.		Erste Methode: hat den Vorteil, dass bei Programmende das Objekt automatisch zerstört wird (und der Destruktor aufgerufen wird). Darüber, wann das passiert, hat man aber keine Kontrolle.
	<~~code~~=cpp>		<syntaxhighlight lang="cpp">
	class Singleton		class Singleton
	{		{
Zeile 112:		Zeile 112:
	return &instance;		return &instance;
	}		}
	</~~code=cpp~~>		</syntaxhighlight>
	Zweite Methode: Vorteil dieser ist, dass man bei Erzeugung des Objektes ein spezialisiertes Objekt erzeugen kann, man hat also [[Polymorphie]]. Außerdem hat man durch Hinzufügen einer statischen Destroy()-Funktion volle Kontrolle darüber, wann das Singleton wieder zerstört wird.		Zweite Methode: Vorteil dieser ist, dass man bei Erzeugung des Objektes ein spezialisiertes Objekt erzeugen kann, man hat also [[Polymorphie]]. Außerdem hat man durch Hinzufügen einer statischen Destroy()-Funktion volle Kontrolle darüber, wann das Singleton wieder zerstört wird.
	<~~code~~=cpp>		<syntaxhighlight lang="cpp">
	class Singleton		class Singleton
	{		{
Zeile 145:		Zeile 145:
	instance = 0;		instance = 0;
	}		}
	</~~code=cpp~~>		</syntaxhighlight>

	Dritte Methode: Bietet eine Basisklasse um auf einfachste Weise eine Klasse als Singleton auszuweisen.		Dritte Methode: Bietet eine Basisklasse um auf einfachste Weise eine Klasse als Singleton auszuweisen.
	<~~code~~=cpp>		<syntaxhighlight lang="cpp">
	template <class T_DERIVED>		template <class T_DERIVED>
	class CSingleton		class CSingleton
Zeile 177:		Zeile 177:
	//...		//...
	}		}
	</~~code=cpp~~>		</syntaxhighlight>

	==== Implementierung in [[Actionscript\|Actionscript]] (Version 2) ====		==== Implementierung in [[Actionscript\|Actionscript]] (Version 2) ====
Zeile 217:		Zeile 217:

	==== Implementierung in [[PHP]] (ab Version 5) ====		==== Implementierung in [[PHP]] (ab Version 5) ====
	<~~code~~=php>		<syntaxhighlight lang="php">
	<?php		<?php
	class Singleton {		class Singleton {
Zeile 241:		Zeile 241:
	$singleton = Singleton::getInstance();		$singleton = Singleton::getInstance();
	?>		?>
	</~~code=php~~>		</syntaxhighlight>

	==== Implementierung in [[Python (Programmiersprache)\|Python]] (ab Version 2.2) ====		==== Implementierung in [[Python (Programmiersprache)\|Python]] (ab Version 2.2) ====

L-ectron-X am 8. März 2018 um 19:16 Uhr

2018-03-08T19:16:52Z

← Nächstältere Version		Version vom 8. März 2018, 19:16 Uhr
Zeile 62:		Zeile 62:

	===== mit Threadsicherheit =====		===== mit Threadsicherheit =====
	<~~code~~=csharp>		<syntaxhighlight lang="csharp">
	sealed class Singleton		sealed class Singleton
	{		{
Zeile 80:		Zeile 80:

	// Zugriff über Singleton s=Singleton.getInstance();		// Zugriff über Singleton s=Singleton.getInstance();
	</~~code=csharp~~>		</syntaxhighlight>
	Hinweise zum Code:		Hinweise zum Code:
	# Das private Hilfsobjekt m_lock ist in C# unbedingt notwendig. Die frühere gängige Methode lock(this) {..} hat sich als unzureichend herausgestellt, weil fehlerhafter oder böswilliger Code durch den Aufruf Monitor.Exit(Singleton); die Threadsicherheit einfach aushebeln kann.		# Das private Hilfsobjekt m_lock ist in C# unbedingt notwendig. Die frühere gängige Methode lock(this) {..} hat sich als unzureichend herausgestellt, weil fehlerhafter oder böswilliger Code durch den Aufruf Monitor.Exit(Singleton); die Threadsicherheit einfach aushebeln kann.
Zeile 339:		Zeile 339:
	==== Implementierung in C# ====		==== Implementierung in C# ====
	Eine threadsichere Methode entnommen aus dem MSDN-Mag<ref>http://msdn.microsoft.com/msdnmag/issues/03/02/CQA/</ref>.		Eine threadsichere Methode entnommen aus dem MSDN-Mag<ref>http://msdn.microsoft.com/msdnmag/issues/03/02/CQA/</ref>.
	<~~code~~=csharp>		<syntaxhighlight lang="csharp">
	using System ;		using System ;

Zeile 350:		Zeile 350:
	// Zugriff über		// Zugriff über
	Singleton s = Singleton.Instance ;		Singleton s = Singleton.Instance ;
	</~~code=csharp~~>		</syntaxhighlight>

	Das Singleton-Prinzip wird bei C# durch 2 Maßnahmen erreicht:		Das Singleton-Prinzip wird bei C# durch 2 Maßnahmen erreicht:
Zeile 375:		Zeile 375:
	Auf seiner Basis können dann leicht mehrere verschiedene Singletons erzeugt werden:		Auf seiner Basis können dann leicht mehrere verschiedene Singletons erzeugt werden:

	<~~code~~=csharp>		<syntaxhighlight lang="csharp">
	public class Singleton<T>		public class Singleton<T>
	where T : new()		where T : new()
Zeile 381:		Zeile 381:
	public static readonly T Instance=new T();		public static readonly T Instance=new T();
	}		}
	</~~code=csharp~~>		</syntaxhighlight>
	Ein konkreter Singleton würde dann in etwa so aussehen:		Ein konkreter Singleton würde dann in etwa so aussehen:
	<~~code~~=csharp>		<syntaxhighlight lang="csharp">
	class MeinSingleton : Singleton<MeinSingleton>		class MeinSingleton : Singleton<MeinSingleton>
	{		{
	}		}
	</~~code=csharp~~>		</syntaxhighlight>

	Der Zugriff erfolgt hier über:		Der Zugriff erfolgt hier über:

L-ectron-X: /* ohne Threadsicherheit */

2018-03-08T19:16:08Z

ohne Threadsicherheit

← Nächstältere Version		Version vom 8. März 2018, 19:16 Uhr
Zeile 45:		Zeile 45:

	===== ohne Threadsicherheit =====		===== ohne Threadsicherheit =====
	<~~code~~=csharp>		<syntaxhighlight lang="csharp">
	// Nur zur Veranschaulichung - bitte nicht verwenden!		// Nur zur Veranschaulichung - bitte nicht verwenden!
	sealed class Singleton		sealed class Singleton
Zeile 59:		Zeile 59:

	// Zugriff über Singleton s=Singleton.getInstance();		// Zugriff über Singleton s=Singleton.getInstance();
	</~~code=csharp~~>		</syntaxhighlight>

	===== mit Threadsicherheit =====		===== mit Threadsicherheit =====
	<code=csharp>		<code=csharp>

L-ectron-X am 8. März 2018 um 19:14 Uhr

2018-03-08T19:14:35Z

← Nächstältere Version		Version vom 8. März 2018, 19:14 Uhr
Zeile 14:		Zeile 14:
	* Als Ersatz wird eine neue [[Zugriffsfunktion\|Zugriffsmethode]] angelegt, die eine [[Referenz (Programmierung)\|Referenz]] auf das einzige Objekt zurückgeben kann.		* Als Ersatz wird eine neue [[Zugriffsfunktion\|Zugriffsmethode]] angelegt, die eine [[Referenz (Programmierung)\|Referenz]] auf das einzige Objekt zurückgeben kann.
	* Die [[Variable (Programmierung)\|Variable]], in der das Objekt gespeichert wird, erhält den Modifikator „statisch“ („<code>static</code>“). Sie ist außerdem synchronisiert um die Sicherheit bei nebenläufiger Ausführung zu gewährleisten. Eine alternative Implementierung, die ohne Synchronisierung auskommt, ist unten unter ''[[#Eager Creation\|Eager Creation]]'' gezeigt. In [[Java (Programmiersprache)\|Java]] wird auch dabei das Objekt erst erzeugt wenn es gebraucht wird.		* Die [[Variable (Programmierung)\|Variable]], in der das Objekt gespeichert wird, erhält den Modifikator „statisch“ („<code>static</code>“). Sie ist außerdem synchronisiert um die Sicherheit bei nebenläufiger Ausführung zu gewährleisten. Eine alternative Implementierung, die ohne Synchronisierung auskommt, ist unten unter ''[[#Eager Creation\|Eager Creation]]'' gezeigt. In [[Java (Programmiersprache)\|Java]] wird auch dabei das Objekt erst erzeugt wenn es gebraucht wird.
	<~~code~~=java>		<syntaxhighlight lang="java">
	public final class Singleton {		public final class Singleton {

Zeile 37:		Zeile 37:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>
	Nachteil dieser Variante ist, dass auch nach der Instanziierung jeder Lesezugriff über getInstance(); synchronisiert ist und so mehrere gleichzeitig zugreifende Threads sich gegenseitig blockieren. In Java gibt es hierfür keinen Workaround.		Nachteil dieser Variante ist, dass auch nach der Instanziierung jeder Lesezugriff über getInstance(); synchronisiert ist und so mehrere gleichzeitig zugreifende Threads sich gegenseitig blockieren. In Java gibt es hierfür keinen Workaround.

Zeile 298:		Zeile 298:
	==== Implementierung in [[Java (Programmiersprache)\|Java]] ====		==== Implementierung in [[Java (Programmiersprache)\|Java]] ====
	In [[Java (Programmiersprache)\|Java]] ist diese Implementierung dem Lazy Creation Ansatz vorzuziehen. Die Initialisierung findet durch das späte Initialisieren der Klasse erst statt, wenn die Klasse <code>Singleton</code> referenziert wird.<ref>{{Literatur\|Autor=Tim Lindholm, Frank Yellin\|Titel=The JavaTM TMVirtual Machine Specification\|Auflage=2.\|Seiten=Abschnitt 2.17.4\|Online=[http://java.sun.com/docs/books/vmspec/2nd-edition/html/Concepts.doc.html#19075 online] \|Zugriff=22. Januar 2007}}</ref> Da der Zugriff nur via <code>getInstance()</code> erfolgt, ist dies auch der spätest mögliche Zeitpunkt und entspricht somit der Lazy Evaluation ohne den Synchronisierungs-Overhead.		In [[Java (Programmiersprache)\|Java]] ist diese Implementierung dem Lazy Creation Ansatz vorzuziehen. Die Initialisierung findet durch das späte Initialisieren der Klasse erst statt, wenn die Klasse <code>Singleton</code> referenziert wird.<ref>{{Literatur\|Autor=Tim Lindholm, Frank Yellin\|Titel=The JavaTM TMVirtual Machine Specification\|Auflage=2.\|Seiten=Abschnitt 2.17.4\|Online=[http://java.sun.com/docs/books/vmspec/2nd-edition/html/Concepts.doc.html#19075 online] \|Zugriff=22. Januar 2007}}</ref> Da der Zugriff nur via <code>getInstance()</code> erfolgt, ist dies auch der spätest mögliche Zeitpunkt und entspricht somit der Lazy Evaluation ohne den Synchronisierungs-Overhead.
	<~~code~~=java>		<syntaxhighlight lang="java">
	public final class Singleton {		public final class Singleton {

Zeile 313:		Zeile 313:

	}		}
	</~~code=java~~>		</syntaxhighlight>
	Eine Alternative, welche die Instanz erst beim ersten Aufruf von <code>getInstance()</code> erzeugt, ist unter dem Namen '''initialization on demand holder idiom''' bekannt. Dabei wird die Instanz in einer inneren Klasse <code>Holder</code> erzeugt, welche erst beim ersten Aufruf von <code>getInstance()</code> geladen wird, und nicht schon		Eine Alternative, welche die Instanz erst beim ersten Aufruf von <code>getInstance()</code> erzeugt, ist unter dem Namen '''initialization on demand holder idiom''' bekannt. Dabei wird die Instanz in einer inneren Klasse <code>Holder</code> erzeugt, welche erst beim ersten Aufruf von <code>getInstance()</code> geladen wird, und nicht schon
	beim Laden der Klasse <code>Singleton</code>:		beim Laden der Klasse <code>Singleton</code>:
	<~~code~~=java>		<syntaxhighlight lang="java">
	public final class Singleton {		public final class Singleton {

Zeile 333:		Zeile 333:

	}		}
	</~~code=java~~>		</syntaxhighlight>
	Hierdurch können andere statische Methoden von <code>Singleton</code> gerufen oder in dieser definierte Konstanten referenziert werden, ohne <code>INSTANCE</code> bereits zu erzeugen.		Hierdurch können andere statische Methoden von <code>Singleton</code> gerufen oder in dieser definierte Konstanten referenziert werden, ohne <code>INSTANCE</code> bereits zu erzeugen.

EagleEye: Die Seite wurde neu angelegt: Beispiele für das Singleton. === Lazy Creation === Von Lazy Creation spricht man, wenn das einzige Objekt der Klasse erst erzeugt wir...

2008-09-16T13:42:27Z

Die Seite wurde neu angelegt: Beispiele für das Singleton. === Lazy Creation === Von Lazy Creation spricht man, wenn das einzige Objekt der Klasse erst erzeugt wir...

Neue Seite

Beispiele für das [[Singleton (Design Pattern) | Singleton]].

=== Lazy Creation ===
Von Lazy Creation spricht man, wenn das einzige Objekt der Klasse erst erzeugt wird, wenn es benötigt wird.

Ziel ist, dass der Speicherbedarf und die Rechenzeit für die Instanziierung des Objektes nur dann aufgewendet werden, wenn das Objekt wirklich benötigt wird.

Hierzu wird der Konstruktor ausschließlich beim ersten Aufruf der Funktion getInstance() aufgerufen.

==== Implementierung in [[Java (Programmiersprache)|Java]] ====

Die Erstellung des einmalig existierenden Objekts wird folgendermaßen erreicht:
* Der Konstruktor der Singleton-Klasse ist privat. So ist es von außen nicht möglich, ein weiteres Objekt dieser Klasse zu erzeugen.
* Als Ersatz wird eine neue [[Zugriffsfunktion|Zugriffsmethode]] angelegt, die eine [[Referenz (Programmierung)|Referenz]] auf das einzige Objekt zurückgeben kann.
* Die [[Variable (Programmierung)|Variable]], in der das Objekt gespeichert wird, erhält den Modifikator „statisch“ („<code>static</code>“). Sie ist außerdem synchronisiert um die Sicherheit bei nebenläufiger Ausführung zu gewährleisten. Eine alternative Implementierung, die ohne Synchronisierung auskommt, ist unten unter ''[[#Eager Creation|Eager Creation]]'' gezeigt. In [[Java (Programmiersprache)|Java]] wird auch dabei das Objekt erst erzeugt wenn es gebraucht wird.
<code=java>
public final class Singleton {

/**
* Privates Klassenattribut,
* wird beim erstmaligen Gebrauch (nicht beim Laden) der Klasse erzeugt
*/
private static Singleton instance;

/** Konstruktor ist privat, darf nicht von außen instanziiert werden. */
private Singleton() {}

/**
* Statische Methode "getInstance()" liefert die einzige Instanz der Klasse zurück.
* Ist synchronisiert und somit thread-sicher.
*/
public synchronized static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
</code=java>
Nachteil dieser Variante ist, dass auch nach der Instanziierung jeder Lesezugriff über getInstance(); synchronisiert ist und so mehrere gleichzeitig zugreifende Threads sich gegenseitig blockieren. In Java gibt es hierfür keinen Workaround.

Wenn keine konkreten Gründe dagegen sprechen, ist daher in Java die wesentlich einfachere und effiziente [[#Eager Creation]] (siehe unten) vorzuziehen.

==== Implementierung in [[C#]] ====

===== ohne Threadsicherheit =====
<code=csharp>
// Nur zur Veranschaulichung - bitte nicht verwenden!
sealed class Singleton
{
private Singleton() { }
private static Singleton instance=null;
public static Singleton getInstance()
{
if(instance==null) instance=new Singleton();
return instance;
}
}

// Zugriff über Singleton s=Singleton.getInstance();
</code=csharp>
===== mit Threadsicherheit =====
<code=csharp>
sealed class Singleton
{
private Singleton() { }
private static volatile Singleton instance=null;
public static Singleton getInstance()
{
// DoubleLock
if(instance==null)
lock(m_lock) { if(instance==null) instance=new Singleton(); }
return instance;
}

// Hilfsfeld für eine sichere Threadsynchronisierung
private static Object m_lock = new Object();
}

// Zugriff über Singleton s=Singleton.getInstance();
</code=csharp>
Hinweise zum Code:
# Das private Hilfsobjekt m_lock ist in C# unbedingt notwendig. Die frühere gängige Methode lock(this) {..} hat sich als unzureichend herausgestellt, weil fehlerhafter oder böswilliger Code durch den Aufruf Monitor.Exit(Singleton); die Threadsicherheit einfach aushebeln kann.
# DoubleLock Methode: Warum zweimal dasselbe if()? Damit nach der Instanziierung des Objektes die bremsende Synchronisation per lock() wegfällt, wird dieselbe if-Abfrage zusätzlich vor dem lock-Abschnitt eingesetzt.
# Das Schlüsselwort ''volatile'' ist unbedingt notwendig. (s. [http://discuss.develop.com/archives/wa.exe?A2=ind0203B&L=DOTNET&P=R375 The DOTNET Memory Model])

Falls es keine konkreten Einwände gibt, dass das Singleton-Objekt auch schon ''etwas'' früher instanziiert werden darf, ist der unter [[#Eager Creation]] beschriebene Code einfacher und schneller und daher in C# vorzuziehen.

==== Implementierung in [[C++]] ====

Vorsicht: Die beiden folgenden Implementierungen sind nicht korrekt, da mehr als nur eine Instanz erstellt werden kann, sofern mehrere Threads gleichzeitig getInstance() aufrufen. Sie dienen nur als Beispiel und sollten in dieser Form ohne Locking nicht in großen Projekten verwendet werden.

Erste Methode: hat den Vorteil, dass bei Programmende das Objekt automatisch zerstört wird (und der Destruktor aufgerufen wird). Darüber, wann das passiert, hat man aber keine Kontrolle.
<code=cpp>
class Singleton
{
private:
//Konstruktor private, damit man sich keine Instanzen holen kann.
Singleton();
//Den Kopierkonstruktor schützen um zu vermeiden, dass das Objekt unbeabsichtigt kopiert wird.
Singleton(const Singleton& cc);

public:
~Singleton();
static Singleton* getInstance();
};

Singleton* Singleton::getInstance()
{
static Singleton instance;
return &instance;
}
</code=cpp>
Zweite Methode: Vorteil dieser ist, dass man bei Erzeugung des Objektes ein spezialisiertes Objekt erzeugen kann, man hat also [[Polymorphie]]. Außerdem hat man durch Hinzufügen einer statischen Destroy()-Funktion volle Kontrolle darüber, wann das Singleton wieder zerstört wird.
<code=cpp>
class Singleton
{
private:
//Ein Pointer zum Speichern der Instanz
static Singleton* instance;
//Konstruktor private, damit man sich keine Instanzen holen kann.
Singleton();
//Den Kopierkonstruktor schützen um zu vermeiden, dass das Objekt unbeabsichtigt kopiert wird.
Singleton(const Singleton& cc);
~Singleton();
public:
static Singleton* getInstance();
static void Destroy();
};

Singleton* Singleton::instance = 0;

Singleton* Singleton::getInstance()
{
if( !instance )
instance = new Singleton();
return instance;
}

void Singleton::Destroy()
{
// static
delete instance;
instance = 0;
}
</code=cpp>

Dritte Methode: Bietet eine Basisklasse um auf einfachste Weise eine Klasse als Singleton auszuweisen.
<code=cpp>
template <class T_DERIVED>
class CSingleton
{
public:
static T_DERIVED& GetInstance()
{
static T_DERIVED oInstance ;
return oInstance ;
}

protected:
CSingleton(){}

private:
CSingleton( const CSingleton& ) ;
CSingleton& operator=( const CSingleton& ) ;
} ;

// Verwendung
class CMySingleton : public CSingleton< CMySingleton >
{
friend class CSingleton< CMySingleton >;

private:
CMySingleton(){}

//...
}
</code=cpp>

==== Implementierung in [[Actionscript|Actionscript]] (Version 2) ====

<code=actionscript>

class SingeltonClass
{

private static var _instance:SingeltonClass;

private function SingeltonClass()
{
}
/**/
public static function getInstance():SingeltonClass {
if(!_instance) _instance = new SingeltonClass();
return _instance;
}
/**/
public function doSomething()
{
}
}

/*

@use:
import SingeltonClass;

SingeltonClass.getInstance().doSomething();

*/

</code=actionscript>

==== Implementierung in [[PHP]] (ab Version 5) ====
<code=php>
<?php
class Singleton {

// Anlegen der Instanz
private static $instance = NULL;

//Konstruktor private, damit die Klasse nur aus sich selbst heraus instanziiert werden kann.
private function __construct() {}

// Diese statische Methode gibt die Instanz zurueck.
public static function getInstance() {

if (self::$instance === NULL) {
self::$instance = new self;
}
return self::$instance;
}
// Klonen per 'clone()' von außen verbieten.
private function __clone() {}
}

$singleton = Singleton::getInstance();
?>
</code=php>

==== Implementierung in [[Python (Programmiersprache)|Python]] (ab Version 2.2) ====
<code=python>
class Singleton(object):
def __new__(type, *args):
# Falls es noch keine Instanz dieser Klasse gibt, wird eine erstellt und in _the_instance abgelegt.
# Diese wird dann jedes mal zurückgegeben.
if not '_the_instance' in type.__dict__:
type._the_instance = object.__new__(type)
return type._the_instance

def __init__(self):
if not '_ready' in dir(self):
# Der Konstruktor wird bei jeder Instanziierung aufgerufen.
# Einmalige Dinge wie z. B. die Initialisierung von Klassenvariablen müssen also in diesen Block.
self._ready = True
</code=python>

==== Implementierung in [[Perl (Programmiersprache)|Perl]] ====

Die Methode instance gibt $instance zurück, bzw. initialisiert es vorher noch, wenn dies noch nicht geschehen ist.

<code=perl>
package My::Singleton;

use strict; use warnings;

my $instance;

sub instance() {
return $instance or $instance = bless {};
}

42;
</code=perl>

Dies kann dann mit dem folgenden Code genutzt werden:

<code=perl>
use My::Singleton;

my $eins = My::Singleton->instance; # eine neue Instanz
my $zwei = My::Singleton->instance; # die gleiche Instanz

</code=perl>

===== Mit [[CPAN|CPAN]]-Modul =====

Etwas erweiterte Funktionalität bietet das [[CPAN|CPAN]]-Modul Class::Singleton.

=== Eager Creation ===

Zwar ist auch das oben gezeigte Beispiel sicher bezüglich [[Nebenläufigkeit]], weil die zentrale Methode <code>getInstance</code> mit dem Java-Schlüsselwort <code>synchronized</code> markiert ist. Eine einfachere Alternative dazu stellt jedoch die Möglichkeit dar, das Einzelstück bereits während der Initialisierung der Klasse zu erzeugen, die Zugriffsmethode muss es dann nur noch zurückgeben. Daher muss sie nicht synchronisiert werden, was den Zugriff etwas beschleunigt. Dieses Verfahren ist auch als ''eager creation'' (deutsch „begierige Erzeugung“) bekannt.

==== Implementierung in [[Java (Programmiersprache)|Java]] ====
In [[Java (Programmiersprache)|Java]] ist diese Implementierung dem Lazy Creation Ansatz vorzuziehen. Die Initialisierung findet durch das späte Initialisieren der Klasse erst statt, wenn die Klasse <code>Singleton</code> referenziert wird.<ref>{{Literatur|Autor=Tim Lindholm, Frank Yellin|Titel=The JavaTM TMVirtual Machine Specification|Auflage=2.|Seiten=Abschnitt 2.17.4|Online=[http://java.sun.com/docs/books/vmspec/2nd-edition/html/Concepts.doc.html#19075 online] |Zugriff=22. Januar 2007}}</ref> Da der Zugriff nur via <code>getInstance()</code> erfolgt, ist dies auch der spätest mögliche Zeitpunkt und entspricht somit der Lazy Evaluation ohne den Synchronisierungs-Overhead.
<code=java>
public final class Singleton {

/** Privates Klassenattribut, einzige Instanz der Klasse wird erzeugt. */
private static final Singleton INSTANCE = new Singleton();

/** Konstruktor ist privat, darf nicht von außen instanziiert werden. */
private Singleton() {}

/** Statische Methode "getInstance()" liefert die einzige Instanz der Klasse zurück. */
public static Singleton getInstance() {
return INSTANCE;
}

}
</code=java>
Eine Alternative, welche die Instanz erst beim ersten Aufruf von <code>getInstance()</code> erzeugt, ist unter dem Namen '''initialization on demand holder idiom''' bekannt. Dabei wird die Instanz in einer inneren Klasse <code>Holder</code> erzeugt, welche erst beim ersten Aufruf von <code>getInstance()</code> geladen wird, und nicht schon
beim Laden der Klasse <code>Singleton</code>:
<code=java>
public final class Singleton {

/** Private Klasse, einzige Instanz von Singleton wird beim Laden von Holder erzeugt. */
private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}

/** Konstruktor ist privat, darf nicht von außen instanziiert werden. */
private Singleton() {}

/** Statische Methode "getInstance()" liefert die einzige Instanz der Klasse zurück. */
public static Singleton getInstance() {
return Holder.INSTANCE;
}

}
</code=java>
Hierdurch können andere statische Methoden von <code>Singleton</code> gerufen oder in dieser definierte Konstanten referenziert werden, ohne <code>INSTANCE</code> bereits zu erzeugen.

==== Implementierung in C# ====
Eine threadsichere Methode entnommen aus dem MSDN-Mag<ref>http://msdn.microsoft.com/msdnmag/issues/03/02/CQA/</ref>.
<code=csharp>
using System ;

sealed class Singleton
{
private Singleton() { /* ...hier optional Initialisierungscode... */ }
public static readonly Singleton Instance = new Singleton() ;
}

// Zugriff über
Singleton s = Singleton.Instance ;
</code=csharp>

Das Singleton-Prinzip wird bei C# durch 2 Maßnahmen erreicht:
#Durch die Deklaration des Konstruktors als ''privat'' (private Singleton(){}) kann dieser von außerhalb der Klasse nicht mehr aufgerufen werden - das Erstellen des Objektes ist also nur noch von innerhalb der Klasse möglich.
#Das statische öffentliche Feld ''Instance'' speichert und liefert schreibgeschützt Zugriff auf das einzige Objekt der Klasse.

Das Schlüsselwort ''sealed'' teilt dem Compiler mit, dass die Klasse nicht abgeleitet werden darf. Durch den privaten Konstruktor könnten Ableitungen ohnehin nicht instanziiert werden, aber durch ''sealed'' kann der Compiler einige Optimierungen anwenden.

'''Wichtig:'''
Der Konstruktor wird von der [[Common Language Runtime|CLR]] nicht automatisch beim Programmstart aufgerufen.
Erst beim ersten Zugriff auf eine Klasse werden alle statischen Member der Klasse initialisiert – in diesem Fall die Instanziierung des einen Objektes.
Wenn also nie auf diese Klasse zugegriffen wird, wird der Konstruktor auch niemals ausgeführt – und das Objekt wird nie erstellt.
Dieser Effekt tritt auch dann noch ein, wenn die Klasse selbst als ''statisch'' deklariert wird.

Möchte man sicher gehen, dass das Singleton-Objekt beim Programmstart erstellt wird, so muss man einen beliebigen Zugriff in das Hauptprogramm ("public static void Main() { }") einbauen.

===== Varianten =====
#Wenn man seine Klasse wie in o. g. Beispiel nicht von einer anderen Klasse ableiten muss, kann man die Klasse auch einfach als statisch deklarieren – das entspricht immer noch dem Singleton-Prinzip. Das o. g. Beispiel ist eigentlich nur ein Workaround für die Tatsache, dass man in C# statische Klassen nicht von anderen Klassen ableiten kann.
#Möchte man eine bestimmte Anzahl Instanzen dieser Klasse ([[Multiton]]), so kann man einfach weitere statische öffentliche Instanzfelder hinzufügen ("public static readonly Singleton Instance2 = new Singleton() ;").

==== Implementierung als Generic in C# ab .Net 2.0 ====

Mit dieser Implementierung muss das Singleton nur einmal implementiert werden.
Auf seiner Basis können dann leicht mehrere verschiedene Singletons erzeugt werden:

<code=csharp>
public class Singleton<T>
where T : new()
{
public static readonly T Instance=new T();
}
</code=csharp>
Ein konkreter Singleton würde dann in etwa so aussehen:
<code=csharp>
class MeinSingleton : Singleton<MeinSingleton>
{
}
</code=csharp>

Der Zugriff erfolgt hier über:

MeinSingleton.Instance

==== Implementierung in Perl ====

Hier wird $instance bereits bei der Initialisierung von Singleton angelegt. Durch das :shared wird das Beispiel außerdem thead-safe.

<code=perl>
package Singleton;

use strict; use warnings;

my $instance :shared = bless {};

sub instance() { return $instance; }

42;

</code=perl>

[[Kategorie:Design Pattern]]
{{Wikipedia|Seite=Einzelstück_(Entwurfsmuster)}}