{"id":618,"date":"2025-07-25T23:25:28","date_gmt":"2025-07-25T22:25:28","guid":{"rendered":"https:\/\/www.javaeinfacherkl\u00e4rt.de\/?p=618"},"modified":"2025-08-07T23:26:16","modified_gmt":"2025-08-07T22:26:16","slug":"thread-sicheres-singleton-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=618","title":{"rendered":"Thread-sicheres Singleton in Java"},"content":{"rendered":"\n

Das Singleton-Muster<\/strong> ist eines der bekanntesten Entwurfsmuster in der objektorientierten Programmierung. Es sorgt daf\u00fcr, dass von einer Klasse nur genau eine Instanz<\/strong> existiert und bietet einen globalen Zugriffspunkt auf dieses Objekt. In Java kann die Implementierung jedoch schnell problematisch werden, wenn mehrere Threads gleichzeitig auf die Instanz zugreifen \u2013 Stichwort Thread-Sicherheit<\/strong>. In diesem Artikel betrachten wir verschiedene M\u00f6glichkeiten, wie man ein Singleton in Java korrekt und thread-sicher<\/strong> implementiert.<\/p>\n\n\n\n

\n\n\n\n

Warum \u00fcberhaupt Singleton?<\/strong><\/h2>\n\n\n\n

Ein Singleton wird oft eingesetzt, wenn:<\/p>\n\n\n\n

    \n
  • Eine zentrale Steuerinstanz<\/strong> ben\u00f6tigt wird (z.\u202fB. Logger, Konfigurationsmanager, Cache).<\/li>\n\n\n\n
  • Der Zugriff auf gemeinsame Ressourcen<\/strong> zentral geregelt werden soll.<\/li>\n\n\n\n
  • Eine gemeinsame Datenbasis<\/strong> innerhalb einer Anwendung verf\u00fcgbar sein soll.<\/li>\n<\/ul>\n\n\n\n
    \n\n\n\n

    Die Grundform eines Singleton (nicht thread-sicher)<\/strong><\/h2>\n\n\n
    public<\/span> class<\/span> Singleton<\/span> <\/span>{\n    private<\/span> static<\/span> Singleton instance;\n\n    private<\/span> Singleton() {\n        \/\/ private Konstruktor<\/span>\n    }\n\n    public<\/span> static<\/span> Singleton getInstance() {\n        if<\/span> (instance == null<\/span>) {\n            instance = new<\/span> Singleton();\n        }\n        return<\/span> instance;\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Dieses Beispiel ist nicht thread-sicher<\/strong>. Wenn zwei Threads gleichzeitig getInstance()<\/code> aufrufen und instance == null<\/code> ist, kann es passieren, dass beide Threads eine neue Instanz erstellen.<\/p>\n\n\n\n
    \n\n\n\n
    Thread-sichere Varianten<\/strong><\/h2>\n\n\n\n
    1. Synchronisierte Methode (einfach, aber ineffizient)<\/strong><\/h3>\n\n\n
    public<\/span> class<\/span> Singleton<\/span> <\/span>{\n    private<\/span> static<\/span> Singleton instance;\n\n    private<\/span> Singleton() {}\n\n    public<\/span> static<\/span> synchronized Singleton getInstance() {\n        if<\/span> (instance == null<\/span>) {\n            instance = new<\/span> Singleton();\n        }\n        return<\/span> instance;\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Vorteile:<\/strong><\/p>\n\n\n\n
      \n
    • Einfach zu verstehen.<\/li>\n\n\n\n
    • Thread-sicher.<\/li>\n<\/ul>\n\n\n\n
      Nachteile:<\/strong><\/p>\n\n\n\n
        \n
      • Die Synchronisierung verlangsamt den Zugriff \u2013 selbst wenn das Objekt bereits initialisiert ist.<\/li>\n<\/ul>\n\n\n\n
        \n\n\n\n
        2. Double-Checked Locking (effizienter)<\/strong><\/h3>\n\n\n
        public<\/span> class<\/span> Singleton<\/span> <\/span>{\n    private<\/span> static<\/span> volatile Singleton instance;\n\n    private<\/span> Singleton() {}\n\n    public<\/span> static<\/span> Singleton getInstance() {\n        if<\/span> (instance == null<\/span>) {\n            synchronized (Singleton.class<\/span>) <\/span>{\n                if<\/span> (instance == null<\/span>) {\n                    instance = new<\/span> Singleton();\n                }\n            }\n        }\n        return<\/span> instance;\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
        Was ist hier neu?<\/strong><\/p>\n\n\n\n
          \n
        • Die Variable ist als volatile<\/code> deklariert, um Instruktionsreordering<\/strong> zu verhindern.<\/li>\n\n\n\n
        • Zwei Pr\u00fcfungen auf instance == null<\/code>, eine au\u00dferhalb und eine innerhalb des synchronized<\/code>-Blocks \u2013 daher der Name \u201edouble-checked locking\u201c.<\/li>\n<\/ul>\n\n\n\n
          Vorteile:<\/strong><\/p>\n\n\n\n
            \n
          • Schnell, sobald die Instanz einmal erzeugt wurde.<\/li>\n\n\n\n
          • Thread-sicher ohne unn\u00f6tige Synchronisation.<\/li>\n<\/ul>\n\n\n\n
            Nachteile:<\/strong><\/p>\n\n\n\n
              \n
            • Etwas komplexer zu verstehen.<\/li>\n\n\n\n
            • Funktioniert erst ab Java 1.5 korrekt (wegen volatile<\/code>).<\/li>\n<\/ul>\n\n\n\n
              \n\n\n\n
              3. Initialisierung-on-Demand-Holder (empfohlene Methode)<\/strong><\/h3>\n\n\n
              public<\/span> class<\/span> Singleton<\/span> <\/span>{\n    private<\/span> Singleton() {}\n\n    private<\/span> static<\/span> class<\/span> Holder<\/span> <\/span>{\n        private<\/span> static<\/span> final<\/span> Singleton INSTANCE = new<\/span> Singleton();\n    }\n\n    public<\/span> static<\/span> Singleton getInstance() {\n        return<\/span> Holder.INSTANCE;\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
              Funktionsweise:<\/strong><\/p>\n\n\n\n
                \n
              • Die Instanz wird in einer statischen inneren Klasse<\/strong> gehalten.<\/li>\n\n\n\n
              • Die Klasse Holder<\/code> wird erst geladen<\/strong>, wenn getInstance()<\/code> aufgerufen wird.<\/li>\n\n\n\n
              • Die Java Virtual Machine garantiert, dass die Initialisierung von INSTANCE<\/code> thread-sicher<\/strong> ist.<\/li>\n<\/ul>\n\n\n\n
                Vorteile:<\/strong><\/p>\n\n\n\n
                  \n
                • Lazy Loading<\/strong> ohne explizite Synchronisierung.<\/li>\n\n\n\n
                • Sehr effizient.<\/li>\n\n\n\n
                • Einfache und elegante L\u00f6sung.<\/li>\n<\/ul>\n\n\n\n
                  Nachteile:<\/strong><\/p>\n\n\n\n
                    \n
                  • Weniger bekannt; f\u00fcr einige Entwickler schwerer zu durchschauen.<\/li>\n<\/ul>\n\n\n\n
                    \n\n\n\n
                    4. Enum-Singleton (besonders robust)<\/strong><\/h3>\n\n\n
                    public<\/span> enum Singleton {\n    INSTANCE;\n\n    public<\/span> void doSomething() {\n        \/\/ Methode aufrufen<\/span>\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Was macht diese L\u00f6sung besonders?<\/strong><\/p>\n\n\n\n
                      \n
                    • Enums sind per Definition thread-sicher<\/strong> und vor Serialisierungsangriffen<\/strong> gesch\u00fctzt.<\/li>\n\n\n\n
                    • Auch bei Deserialisierung<\/strong> oder Reflection<\/strong> bleibt das Singleton intakt.<\/li>\n<\/ul>\n\n\n\n
                      Vorteile:<\/strong><\/p>\n\n\n\n
                        \n
                      • K\u00fcrzester Code.<\/li>\n\n\n\n
                      • Automatisch thread-sicher.<\/li>\n\n\n\n
                      • Schutz gegen komplexe Fehlerquellen (z.\u202fB. durch Deserialisierung).<\/li>\n<\/ul>\n\n\n\n
                        Nachteile:<\/strong><\/p>\n\n\n\n
                          \n
                        • Weniger flexibel (z.\u202fB. keine Vererbung m\u00f6glich).<\/li>\n\n\n\n
                        • F\u00fcr viele Entwickler ungewohnt.<\/li>\n<\/ul>\n\n\n\n
                          \n\n\n\n
                          Was ist mit Serialisierung?<\/strong><\/h2>\n\n\n\n
                          Ein Problem klassischer Singleton-Implementierungen ist, dass durch Deserialisierung<\/strong> eine neue Instanz erzeugt werden kann. Um das zu verhindern, sollte man readResolve()<\/code> \u00fcberschreiben:<\/p>\n\n\n
                          private Object<\/span> readResolve() {\n    return<\/span> getInstance();\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Beim Enum-Singleton tritt dieses Problem nicht auf<\/strong>, da Enums automatisch serialisierungsfest sind.<\/p>\n\n\n\n
                          \n\n\n\n
                          Zusammenfassung und Empfehlung<\/strong><\/h2>\n\n\n\n
                          Variante<\/th>Thread-sicher<\/th>Lazy Loading<\/th>Einfachheit<\/th>Performance<\/th><\/tr><\/thead>
                          Unsynchronisiert<\/td>\u274c<\/td>\u2705<\/td>\u2705<\/td>\u2705<\/td><\/tr>
                          Synchronisierte Methode<\/td>\u2705<\/td>\u2705<\/td>\u2705<\/td>\u274c<\/td><\/tr>
                          Double-Checked Locking<\/td>\u2705<\/td>\u2705<\/td>\u2796<\/td>\u2705<\/td><\/tr>
                          Static Holder<\/td>\u2705<\/td>\u2705<\/td>\u2705<\/td>\u2705<\/td><\/tr>
                          Enum<\/td>\u2705<\/td>\u274c (sofort bei Laden)<\/td>\u2705<\/td>\u2705<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                          Empfehlung:<\/strong><\/p>\n\n\n\n
                            \n
                          • F\u00fcr die meisten Anwendungen ist die Holder-Variante<\/strong> die beste Wahl.<\/li>\n\n\n\n
                          • Wenn Robustheit gegen Reflection und Serialisierung wichtig ist, sollte man die Enum-Variante<\/strong> verwenden.<\/li>\n\n\n\n
                          • Die synchronisierte Methode ist nur f\u00fcr einfache, nicht performance-kritische Anwendungen geeignet.<\/li>\n<\/ul>\n\n\n\n
                            \n\n\n\n
                            Fazit<\/strong><\/h2>\n\n\n\n
                            Die Implementierung eines Singleton in Java scheint auf den ersten Blick trivial \u2013 doch gerade in mehrthreadigen Anwendungen<\/strong> kann sie zu unerwarteten Fehlern f\u00fchren. Java bietet mehrere M\u00f6glichkeiten, ein Singleton thread-sicher<\/strong> zu gestalten, jede mit ihren eigenen Vor- und Nachteilen. Wer Wert auf Effizienz und Sicherheit<\/strong> legt, sollte entweder das Initialisierung-on-Demand Holder Pattern<\/strong> oder die Enum-Variante<\/strong> verwenden.<\/p>\n","protected":false},"excerpt":{"rendered":"
                            Das Singleton-Muster ist eines der bekanntesten Entwurfsmuster in der objektorientierten Programmierung. Es sorgt daf\u00fcr, dass von einer Klasse nur genau eine Instanz existiert und bietet einen globalen Zugriffspunkt auf dieses Objekt. In Java kann die Implementierung jedoch schnell problematisch werden, wenn mehrere Threads gleichzeitig auf die Instanz zugreifen \u2013 Stichwort Thread-Sicherheit. In diesem Artikel betrachten […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-618","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/618","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=618"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/618\/revisions"}],"predecessor-version":[{"id":619,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/618\/revisions\/619"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=618"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=618"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=618"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}