Singletons - Segen oder Fluch?
Ich bin nun das ein oder andere mal darüber gestolpert. Das Singleton Pattern erfreut sich oft großer Beliebtheit. Ob es eine zentrale Stelle ist, die kontrolliert mit Resourcen umgeht, oder einfach die ASP.NET Session Keys wegkapselt, das Singleton Pattern wird oft dafür hergenommen.
Was viele jedoch nicht Bedenken ist das unter Umständen auch mehrere Threads auf dieses Singleton zugreifen möchten. Insbesondere dann, wenn ein Singleton in eine Anwendung Implementiert wird, die Definitiv mit mehreren Threads arbeitet. Web Anwendungen wären hier ein gutes Beispiel.
Ein kleines Beispiel. Ein ID-Generator soll zentral in der Anwendung zugänglich gemacht werden. Im folgenden das Interface:
public interface ISequence
{
int GetNext();
}
Was liegt näher als das ganze als Singleton zu implementieren. Eine Klasse die sich exakt einmal im Speicher einer Anwendung instanzieren lässt und diese Instanz immer wieder verwendet, um auf Eigenschaften und Methoden zuzugreifen. Hier der erste Ansatz:
public class Sequencer : ISequence
{
private static Sequencer instance = null;
private int nextId = 0;
private Sequencer()
{
}
public static Sequencer Instance
{
get
{
if( instance == null )
{
instance = new Sequencer();
}
return instance;
}
}
#region ISequence Members
public int GetNext()
{
return nextId++;
}
#endregion
}
Sieht eigentlich gut aus. Kein öffentlicher Konstruktor, die Instanz wird über ein statisches Property zurückgegeben und die Implementierung zählt die ID hoch. Testet man jedoch das ganze mit mehreren Threads, wird man schnell merken das man doch noch etwas zu tun hat.
class Program
{
static HashSet<int> numbers1 = new HashSet<int>();
static HashSet<int> numbers2 = new HashSet<int>();
static void Main( string[] args )
{
Thread thread1 = new Thread( new ThreadStart( CollectNumbers1 ) );
Thread thread2 = new Thread( new ThreadStart( CollectNumbers2 ) );
thread1.Start();
thread2.Start();
thread1.Join();
thread2.Join();
var differences = numbers1.Except( numbers2 );
Console.WriteLine( differences.Count() );
}
static void CollectNumbers1()
{
for( int i = 0; i < 100000; i++ )
{
numbers1.Add( Sequencer.Instance.GetNext() );
}
}
static void CollectNumbers2()
{
for( int i = 0; i < 100000; i++ )
{
numbers2.Add( Sequencer.Instance.GetNext() );
}
}
}
Das Test-Programm läuft in zwei Threads über den Sequencer und merkt sich jeweils in einem eigenen Hash-Set die Ergebnisse. Die Differenz müsste genau 100.000 sein. Startet man die Anwendung erhält man sehr unterschiedliche Ergebnisse wie z.B. 69403, 75839, 66848 usw.
Die GetNext() Methode ist nicht thread-safe implementiert. Um einen Thread exklusiv mit Daten arbeiten zu lassen, sollte man den Bereich Markieren, indem man Synchronisationsobjekte benutzt. Für das Hochzählen eines Wertes gibt es bereits eine Kapselung im System.Threading Namensbereich: Interlocked.Increment. Hier die angepasste GetNext() Methode:
public int GetNext()
{
// return nextId++;
return Interlocked.Increment( ref nextId );
}
Ist man nun am Ziel?
Ich glaube nicht, Tim!
Nach erneuten Testläufen wird man feststellen, das die Implementierung immer noch nicht thread-safe ist. Die Instanzierung, der erste Zugriff auf das Singleton scheint das Problem zu sein.
Die Ergebnisse bringen, je nach Startup-Verhalten der Anwendung, unterschiedliche Werte: 99.999 oder 100.000. Letzteres wäre perfekt, das gewünschte Resultat, doch die 99.999 warnen uns, wir haben ein Problem.
Genau deshalb finde ich den Titel "Singletons - Segen oder Fluch?" so passend. Race Conditions und Thread Synchronisierungs Probleme sieht man im ersten Augenblick nicht unbedingt. Selbst wenn getestet wird, kann sich durch den Debugging Build unter Umständen ein anderes Laufzeitverhalten ergeben, als im Produktiv-Betrieb später.
Der Singleton selbst scheint einfach zu implementieren und wenn man sicher ist das nicht mehrere Threads parallel darauf zugreifen können, ist die obere Implementierung auch vollkommen in Ordnung. Und ich habe in vielen Anwendungen genau diese Implementierung gesehen. Eine einfache Implementierung: Ein Segen! Ein nicht so einfach festzustellender Laufzeit-Fehler, ein Fluch!
Doch um ein Singleton wirklich thread-safe zu schreiben, benötigt man für die Instanzierung ein paar kleine Kniffe. Zuerst einmal die thread-safe Implementierung:
public sealed class SequencerThreadSafeCustom : ISequence
{
private static volatile SequencerThreadSafeCustom instance;
private static object cs = new object();
private int nextId = 0;
private SequencerThreadSafeCustom()
{
}
public static SequencerThreadSafeCustom Instance
{
get
{
if( instance == null )
{
lock( cs )
{
if( instance == null )
{
instance = new SequencerThreadSafeCustom();
}
}
}
return instance;
}
}
#region ISequence Members
public int GetNext()
{
return Interlocked.Increment( ref nextId );
}
#endregion
}
In Zeile 3 wird das volatile keyword verwendet. Mal ehrlich, wer hat das schon bisher benutzt? Es gibt dem Compiler Hinweise das die Variable mit Sicherheit von mehreren Threads benutzt wird und dieser keine Optimierungen machen kann die für einen Thread sinnvoll wären.
Die Instance Eigenschaft aus Zeile 12 erhält nun eine doppelte Abfrage und sichert über ein synchronizations Objekt, das die Instanzierung auch nur einmal durchgeführt wird. Das war es auch schon.
Auf MSDN Solve gibt es noch den passenden Screencast zu diesem Beitrag.