Pre

In der Welt der Software-Architektur und des Entwurfsmusters ist der Begriff demi singleton eine spannende Weiterentwicklung des klassischen Singleton-Konzepts. Dieses Konzept, das in vielen Programmiersprachen als Garant für eine einzige Instanz in einem gegebenen Kontext verstanden wird, erhält durch den demi singleton eine flexible Erweiterung. In diesem umfassenden Leitfaden erklären wir, was demi singleton bedeutet, wie es funktioniert, welche Vor- und Nachteile es hat und wie man es in verschiedenen Programmiersprachen sinnvoll implementiert. Ziel ist es, dass Leserinnen und Leser das Muster verstehen, bewerten und in realen Projekten anwenden können – mit klaren Beispielen, Best Practices und verständlichen Gegenüberstellungen zum klassischen Singleton.

Was bedeutet demi singleton und wie grenzt es sich vom klassischen Singleton ab?

Der Begriff demi singleton kombiniert zwei Konzepte: „demi“ als Anspielung auf halb, teilweise oder halbnachvollziehbar, und „singleton“, das klassische Entwurfsmuster, das sicherstellt, dass eine Klasse genau eine Instanz besitzt und global zugänglich ist. Der demi singleton erweitert dieses Prinzip um Flexibilität: Es besitzt in der Regel eine primäre, globale Instanz, erlaubt aber in bestimmten Kontexten die Erzeugung alternativer Instanzen oder isolierter Kopien. Damit reagiert es auf typische Anforderungen in großen Anwendungen, bei denen globale Zustände störend wirken können, zum Beispiel bei Tests, Mehrmandanten-Architekturen oder modular aufgebauten Anwendungen.

Kurz gesagt: Demi Singleton versucht, die Vorteile des Singleton-Musters – konsistente globale Zustandshaltung, zentrale Koordination und Ressourcenkontrolle – mit der Notwendigkeit nach testbarer, isolierbarer oder kontextspezifischer Instanziierung zu verbinden. Das Ergebnis ist ein Muster, das sich flexibel an verschiedene Kontextgruppierungen anpasst, ohne die Klarheit und Steuerbarkeit globaler Zustände zu verlieren. Dieser Ansatz macht demi singleton zu einer sinnvollen Variante, wenn Reinheit des globalen Zustands und Modularität miteinander im Konflikt stehen.

Ursprung, Theorie und Prinzipien des demi singleton

Der demi singleton wurzelt in der Idee, dass nicht alle Anwendungsbereiche einer einzigen, globalen Instanz folgen müssen. In komplexen Systemen kann es sinnvoll sein, eine zentrale Instanz für allgemeinen Zugriff zu haben, aber innerhalb eines Moduls, eines Testsuiten-Kontexts oder einer bestimmten Thread- oder Kontextumgebung separate Instanzen zu verwenden. Die theoretische Grundlage bildet daher eine hybride Struktur zwischen einem stricten Singleton und einer loseren, instanziierten Architektur.

Wesentliche Prinzipien des demi singleton sind:

  • Globale Standardinstanz: Es existiert mindestens eine zentrale Instanz, die standardmäßig verwendet wird.
  • Kontextbasierte Abweichungen: In bestimmten Kontexten dürfen weitere Instanzen existieren, ohne den globalen Zustand zu gefährden.
  • Schlanke Koordination: Der Zugriff erfolgt über zentral definierte Mechanismen, die sicherstellen, dass Instanzen konsistent verwaltet werden.
  • Testbarkeit und Modularität: Durch kontextspezifische Instanzen wird das Testen einzelner Module erleichtert.

Technisch gesehen bedeutet das oft die Implementierung von Pfaden zur Isolation, wie z. B. pro Thread, pro Request, pro Modul oder pro Testfall. Welche Form der Isolation gewählt wird, hängt von den Anforderungen der Anwendung ab. Wichtig ist, dass die Mechanik robust genug ist, um Synchronisation, Lazy Initialization und Resourcenmanagement sauber zu handhaben.

Im Folgenden werfen wir einen Blick auf konkrete Implementierungsansätze des demi singleton in drei populären Sprachen: Python, Java und JavaScript/TypeScript. Ziel ist es, die Konzepte greifbar zu machen und zu zeigen, wie man demi singleton sinnvoll in realen Projekten einsetzen kann.

Demi Singleton in Python

Python eignet sich gut, um das Konzept des demi singleton durch flexible Instanzverwaltung umzusetzen. Eine übliche Herangehensweise ist die Nutzung einer zentralen Registry, die Instanzen pro Kontext hält. Zusätzlich kann man Thread- oder Kontextvariablen verwenden, um sicherzustellen, dass in einem bestimmten Kontext eine eigene Instanz existiert.


import threading
import contextvars

class DemiSingleton:
    _global_instance = None
    _lock = threading.Lock()
    _context_instances = {}

    # Kontext- Schlüssel können z. B. Namespaces, Request-IDs etc. sein.
    _context_key = contextvars.ContextVar("demi_context", default=None)

    @classmethod
    def set_context_key(cls, key):
        cls._context_key.set(key)

    @classmethod
    def get_instance(cls):
        key = cls._context_key.get()
        if key is None:
            # Standard-Globale Instanz verwenden
            if cls._global_instance is None:
                with cls._lock:
                    if cls._global_instance is None:
                        cls._global_instance = cls()
            return cls._global_instance
        else:
            # Kontext-spezifische Instanz
            if key not in cls._context_instances:
                cls._context_instances[key] = cls()
            return cls._context_instances[key]
    
    def __init__(self):
        self.value = "Standard-DemiSingleton"

# Nutzung
# Globale Instanz
inst1 = DemiSingleton.get_instance()

# Kontextbasierte Instanz
DemiSingleton.set_context_key("request-123")
inst2 = DemiSingleton.get_instance()
```


Dieses Muster illustriert, wie man eine globale Standardinstanz beibehält, aber in bestimmten Kontexten separate Instanzen erzeugen kann. In der Praxis können die Kontextschlüssel flexibel gestaltet werden, z. B. pro Thread, pro HTTP-Anfrage oder pro Testfall. Wichtig ist eine klare Dokumentation der Kontextlogik, damit Code-Reviewer die Instanzierung nachvollziehen können.



Demi Singleton in Java



In Java eignen sich die Möglichkeiten der Thread-Sicherheit und der statischen Initialisierung besonders gut, um demi singleton sicher umzusetzen. Eine gängige Strategie ist die Verwendung eines zentralen Registries im Singleton-Muster mit kontextabhängigen Instanzen, ergänzt durch Synchronisation oder die Verwendung von ConcurrentHashMap.




// Demis Singleton in Java – kontextabhängige Instanzen
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;

public class DemiSingleton {
    private static final AtomicReference GLOBAL = new AtomicReference<>();
    private static final ConcurrentHashMap CONTEXT_MAP = new ConcurrentHashMap<>();

    private DemiSingleton() {
        // privater Konstruktor
    }

    public static DemiSingleton getInstance() {
        DemiSingleton instance = GLOBAL.get();
        if (instance == null) {
            synchronized (GLOBAL) {
                instance = GLOBAL.get();
                if (instance == null) {
                    instance = new DemiSingleton();
                    GLOBAL.set(instance);
                }
            }
        }
        return instance;
    }

    public static DemiSingleton getInstanceForContext(String contextKey) {
        return CONTEXT_MAP.computeIfAbsent(contextKey, k -> new DemiSingleton());
    }

    // Beispiel-Eigenschaften
    private String data = "Standard-DemiSingleton";

    public String getData() { return data; }
    public void setData(String d) { data = d; }
}



In diesem Java-Beispiel wird eine globale Instanz zentral verwaltet, während kontextbezogene Instanzen in einer ConcurrentHashMap gehalten werden. Der Zugriff erfolgt über zwei unterschiedliche Pfade: eine globale Methode, die die Standardinstanz liefert, und eine kontextbasierte Methode, die in Abhängigkeit des Kontextschlüssels eine eigene Instanz erzeugt oder zurückgibt. Diese Lösung betont die sichere Handhabung in Mehrthread-Umgebungen und ermöglicht dennoch eine feine Granularität der Instanzen.


Demi Singleton in JavaScript/TypeScript


Für Webanwendungen oder Node.js-Umgebungen bietet JavaScript/TypeScript flexible Muster, um demi singleton umzusetzen – oft mit Hilfe von Map-Strukturen und kontextbezogener Scope-Verwaltung. In TypeScript lässt sich dies sauber typisieren, während in reinem JavaScript der Fokus auf Klarheit und Robustheit liegt.



// Demi Singleton in TypeScript (kontextabhängig)
class DemiSingleton {
  private static globalInstance?: DemiSingleton;
  private static contextMap: Map = new Map();

  private constructor() {}

  public static getGlobalInstance(): DemiSingleton {
    if (!DemiSingleton.globalInstance) {
      DemiSingleton.globalInstance = new DemiSingleton();
    }
    return DemiSingleton.globalInstance;
  }

  public static getInstanceForContext(contextKey: string): DemiSingleton {
    if (!DemiSingleton.contextMap.has(contextKey)) {
      DemiSingleton.contextMap.set(contextKey, new DemiSingleton());
    }
    return DemiSingleton.contextMap.get(contextKey)!;
  }

  public info(): string {
    return "DemiSingleton-Instanz";
  }
}

// Nutzung
const global = DemiSingleton.getGlobalInstance();
const ctxA = DemiSingleton.getInstanceForContext("ctx-A");



Demi Singleton vs. klassischer Singleton: Vor- und Nachteile


Wie bei vielen Entwurfsmustern hängt die Nützlichkeit des demi singleton stark davon ab, wie gut es zum jeweiligen Anwendungskontext passt. Hier eine kompakte Gegenüberstellung:


    

  • Vorteile:

      

    • Erhöhte Flexibilität: Globale Zentralisierung bleibt erhalten, Kontextinstanzen ermöglichen Isolation und bessere Testbarkeit.
      • 

    • Verbesserte Testbarkeit: In Tests lassen sich kontextabhängige Instanzen leicht erzeugen, ohne globale Seiteneffekte zu riskieren.
      • 

    • Modularität: Anwendungen mit klaren Kontextgrenzen können leichter skaliert und gewartet werden.
      • 

    

    • 

  • Nachteile:

      

    • Kompizität: Der Code wird komplexer, da mehrere Pfade der Instanzierung gepflegt werden müssen.
      • 

    • Synchronisationsaufwand: In mehrthreadigen Umgebungen muss sorgfältig abgesichert werden, um Race Conditions zu vermeiden.
      • 

    • Weniger vorhersehbares Verhalten: Ohne klare Konventionen darüber, wann welche Instanz verwendet wird, kann es zu Verwirrung kommen.
      • 

    

    • 



Der demi singleton sollte daher nur dort eingesetzt werden, wo eine echte Notwendigkeit für kontextabhängige Instanzen besteht. In vielen Projekten genügt das klassische Singleton oder eine Dependency-Injection-Strategie, bei der Abhängigkeiten gezielt und testbar injiziert werden.


Anwendungsbereiche des demi singleton


Welche konkreten Szenarien machen den demi singleton besonders sinnvoll? Hier sind einige typische Anwendungsfelder:


Konfigurationsmanagement und zentrale Ressourcen


Eine häufige Nutzungsmöglichkeit ist die zentrale Verwaltung von Konfigurationsdaten, Verbindungs-Pools oder Loggern. Eine globale Instanz sorgt für Konsistenz, während kontextabhängige Instanzen isolierte Ressourcen darstellen, beispielsweise in Microservice-Architekturen, in denen verschiedene Tenant-Kontexte unterschiedliche Logger- oder Konfigurationspfade benötigen.


Ressourcen- und Verbindungsverwaltung


In datenbanknahen oder netzwerkintensiven Anwendungen kann der demi singleton helfen, Verbindungs-Pools effizient zu nutzen, während in Testläufen oder speziellen Modulen separate Verbindungen verwendet werden können, ohne die globale Pool-Konfiguration zu stören.


Test- und Mock-Strategien


Tests profitieren stark von demi singleton, weil sie so Instanzen isolieren können, ohne globale Zustände zu exportieren. Manchmal ist es sinnvoll, globale Zustände in Tests zu mocken oder temporär zu ersetzen, während der Rest der Anwendung unverändert läuft.




Wie bei jedem fortgeschrittenen Entwurfsmuster gibt es auch bei demi singleton Fallstricke und bewährte Vorgehensweisen, die helfen, robuste Systeme zu bauen.




Lazy Initialization und Thread-Safety


Eine der zentralen Herausforderungen ist das Verhalten bei der initialen Instanziierung. Lazy Initialization spart Ressourcen, kann aber in Mehrthread-Umgebungen zu Race Conditions führen, wenn mehrere Threads gleichzeitig eine Instanz anfordern. Typische Lösungsansätze sind Doppel-Check-Locking, die Verwendung von Atomic- oder Thread-Safe Collections oder die Nutzung von Kontext-Local-Storage statt globaler Tabellen, wenn es sinnvoll ist.


Dependency Injection mit Demi Singleton


Ein sinnvoller Ansatz ist die Kombination aus demi singleton und Dependency Injection (DI). Dabei liefert der DI-Container entweder die globale Instanz oder kontextabhängige Instanzen je nach Konfiguration oder Kontext. So bleiben Änderungen an der Instanziierungslogik zentral steuerbar und der Code bleibt testbar.




Wenn Sie den demi singleton in einem realen Projekt einsetzen möchten, beachten Sie folgende Punkte:


    

  • Definieren Sie klare Kontexte, in denen Instanzen benötigt werden. Vermeiden Sie willkürliche Kontextdefinitionen, um Verwirrung zu verhindern.
    • 

  • Dokumentieren Sie explizit, welches Verhalten in welchem Kontext erwartet wird. Eine gute Dokumentation minimiert Missverständnisse im Team.
    • 

  • Bevorzugen Sie lippe kurze Pfade der Instanziierung. Halten Sie APIs konsistent und eindeutig, um Wartbarkeit zu fördern.
    • 

  • Testen Sie speziell die Grenzfälle: Initialisierung der globalen Instanz, Kontextwechsel, Bereinigung kontextabhängiger Instanzen.
    • 

  • Beachten Sie Auswirkungen auf Performance und Speicherverbrauch. Kontextspezifische Instanzen können Speicherkosten erhöhen; planen Sie Aufräumlogik.
    • 







Wenn Sie sich fragen, ob demi singleton die richtige Wahl für Ihr Projekt ist, nutzen Sie diese kurze Checkliste zur Entscheidung:


    

  • Gibt es legitime Gründe, globale Zustände zu kapseln, aber trotzdem Kontextisierungen zuzulassen?
    • 

  • Erhöhen kontextspezifische Instanzen die Testbarkeit oder Wartbarkeit signifikant?
    • 

  • Wie kompliziert wird der Code durch zusätzliche Pfade der Instanziierung? Sind die Vorteile die Mehrkomplexität wert?
    • 

  • Kirdien Sie Threadsicherheit? Gibt es klare Regeln, wann welche Instanz verwendet wird?
    • 







Im Kapitel weiter unten finden Sie weiterführende Hinweise, wie Sie demi singleton in verschiedenen Umgebungen anwenden können. Zusätzlich haben wir eine Glossar-Sektion, die zentrale Begriffe erklärt und häufige Missverständnisse ausräumt.






Der demi singleton bietet die spannende Möglichkeit, globale Struktur und Kontextualität in Einklang zu bringen. Wer die richtige Balance findet, erhält eine Architektur, die flexibel, testbar und wartbar bleibt. Wer die Balance nicht findet, läuft Gefahr, eine zu komplexe Lösung zu schaffen, deren Wartungskosten höher sind als der Nutzen. Der Schlüssel liegt in klaren Regeln, guter Dokumentation und gezieltem Einsatz nur dort, wo der Kontext wirklich eine kontextabhängige Instanz benötigt.






In modernen Anwendungen ist der demi singleton besonders nützlich in Systemen mit mehreren Mandanten, Remote-Services oder modularen Komponenten. Eine typische Fallstudie könnte wie folgt aussehen:


    

  • Ein SaaS-Anbieter möchte pro Mandant eine eigene Logger-Instanz, während alle Mandanten dieselbe zentrale Konfigurationsinstanz nutzen.
    • 

  • Eine Microservice-Plattform benutzt eine globale Service-Registry, jedoch benötigen einzelne Services temporäre Test- oder Simulationsinstanzen während der Entwicklung oder simulierter Umgebungen.
    • 

  • Eine Webanwendung mit mehreren Sub-Apps (Plug-ins) möchte eine gemeinsame Sitzungshistorie, aber prorate Instanzen pro Benutzer-Session für isolierte Debug-Informationen.
    • 







Der demi singleton ist kein Allzweck-Wundermittel, sondern ein intelligentes Designelement, das dort sinnvoll eingesetzt werden kann, wo klare Kontextgrenzen existieren und gemeinsamer Zustand kritisch gemanagt werden muss. Wenn Sie sorgfältig planen, kontextuale Grenzen definieren und die Instanzen sauber verwalten, kann demi singleton die Robustheit und Flexibilität Ihrer Software signifikant erhöhen. Wie bei jedem Muster gilt: Verstehen, planen, testen und dokumentieren – dann wird demi singleton zu einem echten Gewinn für Ihre Architektur.
By Misc