Singleton

Z Wikipedie, otevřené encyklopedie
Skočit na: Navigace, Hledání

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[editovat | editovat zdroj]

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[editovat | editovat zdroj]

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[editovat | editovat zdroj]

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ší.

Implementace v jazyce Python[editovat | editovat zdroj]

 ## 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#[editovat | editovat zdroj]

class Singleton { 
 
    private static Singleton instance;
 
    //Privatni konstruktor
    private Singleton() { }
 
    //Staticka property (vlastnost) zajistujici vytvoreni instance
    public static Singleton Instance {
        get {
            //Je-li promenna instance null, tak se vytvori objekt
            return instance = instance ?? new Singleton();
        }
    }
}
 
class Program {
    //Pouziti
    public static void Main() {
        var s = Singleton.Instance;
    }
}

Implementace v jazyce C++[editovat | editovat zdroj]

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

Implementace v jazyce PHP[editovat | editovat zdroj]

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[editovat | editovat zdroj]

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. Procesor 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[editovat | editovat zdroj]

  1. a b Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. [s.l.] : Addison-Wesley Professional, 1995. ISBN 0-201-63361-2. (anglicky) 
  2. a b Rudolf Pecinovský. Návrhové vzory. [s.l.] : Computer Press, 2007. ISBN 978-80-251-1582-4. (česky) 
  3. HREBENAR, Jiří. 28. 8. 2009. Dostupné online. (český) 
  4. How to make a singleton in Python, 29. 11. 2009
  5. Marian Böhner. Návrhové vzory v PHP. [s.l.] : Albatros media, 2012. ISBN 978-80-251-3338-5. Kapitola 2, s. 49-57.  
  6. GRUDL, David. . Dostupné online.  

Související články[editovat | editovat zdroj]

Externí odkazy[editovat | editovat zdroj]