Hogyan hozzunk létre egyetlen példányt egy osztályból…

Az Androidban általában a Singleton mintát használják az osztály egyetlen példányának létrehozásához.

Számos Singleton megvalósítás létezik:

Lusta inicializálás szinkronizációval:

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Privát konstruktor megakadályozza más példányok létrehozását
    }

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

Előnyök: Szálbiztos.
Hátrányok: A szinkronizáció csökkentheti a teljesítményt gyakori hívás esetén.

Osztály betöltésekor történő inicializálás (Eager initialization):

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

Előnyök: Szálbiztos szinkronizáció nélkül. Egyszerűbb.
Hátrányok: A példány az osztály betöltésekor jön létre, még akkor is, ha nem használják.

Kétszeri ellenőrzéses zárolás (Double-checked locking):

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

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

Előnyök: Növelt teljesítmény a egyszerű szinkronizációhoz képest, csak szükség esetén inicializál.
Hátrányok: A volatile szükséges a helyes működéshez több szálas környezetben (Java 5-től kezdve). Bonyolultabb.

Statikus belső osztály:

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        public static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

Előnyök: Szálbiztos, lusta inicializálás, egyszerű megvalósítás. A modern Java verziókban ez a legajánlottabb módszer.

Enum használata:

public enum Singleton {
    INSTANCE;

    // Osztálymetódusok hozzáadása
    public void doSomething() {
        // ...
    }
}

Előnyök: A legegyszerűbb és szálbiztos módszer, ellenáll a szériázásnak és a reflexióknak. Gyakran a legjobb gyakorlatnak tartják.

A megvalósítás kiválasztása a teljesítmény- és komplexitási követelményektől függ. Az Androidban gyakran enum vagy statikus belső osztályt használnak.

Hogyan hozzunk létre egyetlen példányt egy osztályból Androidban?