Singleton

Singleton (česky jedináček nebo také unikát) je název pro návrhový vzor používaný při programování. Využijeme ho, když je potřeba, aby v celém programu existovala pouze jedna instance určité třídy. Návrhový vzor také poskytne globální přístupový bod k instanci[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 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) { // Ve standardu C++11 a vyšších lze použít místo NULL nullptr.
            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[4][5]

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

  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. Dostupné online. 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. 
  3. ↑ HREBENAR, Jiří. 28. 8. 2009. Dostupné v archivu pořízeném dne 2009-12-17. (český) 
  4. ↑ Marian Böhner. Návrhové vzory v PHP. [s.l.]: Albatros media, 2012. ISBN 978-80-251-3338-5. Kapitola 2, s. 49–57. 
  5. ↑ GRUDL, David. Dostupné online. 

Související články

Externí odkazy