Singleton: Porovnání verzí

Singleton (česky jedináček nebo také unikát) je název pro návrhový vzor, používaný při programování. Využijeme ho při řešení problému, kdy je potřeba, aby v celém programu běžela pouze jedna instance třídy. Tento návrhový vzor zabezpečí, že třída bude mít jedinou instanci a poskytne k ní globální přístupový bod^[1]. Singleton je také často využíván jako součást jiných návrhových vzorů jako jsou například Flyweight nebo Facade.

Účel

Nutnost existence jediné instance se objevuje například tam, kde potřebujeme, aby se nějaké objekty pohybovaly jen ve vymezeném prostředí – hráči fotbalu hrající na jednom hřišti. Třída definující hřiště vytváří svou instanci jako jedináček. Dalším příkladem mohou být dialogová okna nebo ovladače zařízení^[1]. Známým příkladem ze světa Windows je schránka, která může existovat jen jednou, aby se nám data získaná v jedné aplikaci neztratila někde po cestě do druhé aplikace.

Základní implementace

Implementace jedináčka mají společný soukromý konstruktor, který zaručí, že nedojde k vytvoření další instance. „Požadovaná instance se vytvoří uvnitř třídy a její odkaz se uloží do statického atributu. Jednotlivé varianty implementace se pak odlišují tím, kdy a jak se objekt konstruuje a jak jej mohou ti ostatní získat“^[2].

Implementace v jazyce Java

public class Singleton {

     private static Singleton instance;

     //Vytvorime soukromy konstruktor
     private Singleton() { }
 
     //Metoda pro vytvoreni objektu jedinacek
     public static Singleton getInstance() {
     //Je-li promenna instance null, tak se vytvori objekt
         if (instance == null) {
             instance = new Singleton();
         }
         //Vratime jedinacka
         return instance;
     }
 
     //Pouziti
     public static void main(String[] args) {
         Singleton objekt = Singleton.getInstance();
     }
 }

Ukázka kódu z Java - návrhový vzor Singleton^[3]

Druhá možnost implementace vzoru je následující:

public class Singleton {

    private static final Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }

    // Použití je stejné
    public static void main(String[] args) {
        Singleton objekt = Singleton.getInstance();
    }
}

V tomto případě nemusíme zjišťovat, zda je proměnná inicializovaná - kód je přehlednější a vláknově bezpečný.

Implementace v jazyce Python

 ## Singleton class
 #
 class Foo( object ):
    ## Stores the unique Singleton instance-
    _iInstance = None
 
    ## Class used with this Python singleton design pattern
    #  @todo Add all variables, and methods needed for the Singleton class below
    class Singleton:
        def __init__(self):
            ## a foo class variable
            self.foo = None
 
    ## The constructor
    #  @param self The object pointer.
    def __init__( self ):
        # Check whether we already have an instance
        if Foo._iInstance is None:
            # Create and remember instanc
            Foo._iInstance = Foo.Singleton()
 
        # Store instance reference as the only member in the handle
        self._EventHandler_instance = Foo._iInstance
 
 
    ## Delegate access to implementation.
    #  @param self The object pointer.
    #  @param attr Attribute wanted.
    #  @return Attribute
    def __getattr__(self, aAttr):
        return getattr(self._iInstance, aAttr)
 
 
    ## Delegate access to implementation.
    #  @param self The object pointer.
    #  @param attr Attribute wanted.
    #  @param value Vaule to be set.
    #  @return Result of operation.
    def __setattr__(self, aAttr, aValue):
        return setattr(self._iInstance, aAttr, aValue)
 
 
 ## Test script to prove that it actually works        
 if __name__ == "__main__":
 
    # create a first object
    a = Foo()
 
    # get and print class variable foo
    print a.foo
 
    # create a second object
    b = Foo()
 
    # set a string to the class variable foo
    b.foo = "Hello Folks"
 
    # create a third object
    c = Foo()
 
    # get and print class variable foo for object a
    print a.foo
 
    # get and print class variable foo for object c
    print c.foo

Ukázka kódu z How to make singleton in Python ^[4]

Implementace v jazyce C# (thread safe)

class Singleton {
    
    // okamzita inicializace instance pri prvni pouziti objektu.
    private static Singleton instance = new Singleton();
     
    static Singleton()
    {
    }
    //Privatni konstruktor
    private Singleton() { }

    //Staticka property (vlastnost) zajistujici vraceni instance
    public static Singleton Instance { get { return instance; }}
}

class Program {
    //Pouziti
    public static void Main() {
        var s = Singleton.Instance;
    }
}

Implementace v jazyce C++

class Singleton {
 
private:
    static Singleton *instance;
 
public:
    static Singleton *GetInstance() {
        if (instance == NULL) {
            instance = new Singleton();
        }
        return instance;
    }
 
}

Implementace v jazyce PHP

class Singleton
{
    private static $instance = NULL;

    private function __construct() {
    }

    public static function getInstance() {
        if (self::$instance == NULL) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    public function __clone() {
        trigger_error('Clone is not allowed.', E_USER_ERROR);
    }

    public function __wakeup() {
        trigger_error('Unserializing is not allowed.', E_USER_ERROR);
    }
}

Ukázka kódu v jazyce PHP^[5][6]

Nevýhody

Při využívání vícevláknových aplikací se může stát, že první vlákno požádá o vytvoření jedináčka. Mikroprocesor přepne na druhé vlákno, kde ještě není jedináček vytvořen a je spuštěn proces tvorby jedináčka. Poté je přepnuto na první vlákno, kde byl jedináček započat a je dokončen. Už není jedináček, ale má sourozence. Tomu by se dalo vyhnout synchronizováním tovární metody. Synchronizovat celou metodu je poměrně drahá operace (synchronizovaná metoda se volá vždy při získání instance). Řešení můžeme optimalizovat (v případě, že používáme Javu 5 a vyšší) pomocí definování odkazu na jedináčka jako volatile a synchronizováním bloku kódu, starající se tvorbu jedináčka.

public class Singleton {
    private static volatile Singleton instance = null;

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

Řešení problému vícevláknových aplikací v Javě 5^[2]

Další problém nastává u serializovatelnosti jedináčka. Kdybychom chtěli načítat jedináčka uloženého ze streamu, například souboru, musíme zkontrolovat, jestli již nějaký takový jedináček neexistuje (Java poskytuje metodu, kterou je tato funkcionalita podpořena, jedná se o readSolve(), tato metoda vrací odkaz na aktuálního (původního) jedináčka, ale umožňuje ho například doplnit o novinky jedináčka ze streamu).

Reference

Související články

• Objektově orientované programování

Externí odkazy

• Obrázky, zvuky či videa k tématu Singleton na Wikimedia Commons

• (česky) Návrhový vzor singleton
• (česky) Používáme návrhové vzory v .NET – Singleton
• (česky) Je singleton zlo?
• (česky) Je singleton mrtvý? Ale kdepak
• (anglicky) Vícevláknový singleton na msdn.com
• (anglicky) Jak eliminovat singletony
• (anglicky) Soubor s thread-safe singletonem v jazyce Python
• (anglicky) Vespe Savikko: Design Patterns in Python
• (anglicky) Python Singleton
• (anglicky) PHP5 OOP Patterns