Singleton multithread

[Poker1]

Ciao a tutti!!!
avrei la necessita di creare una classe che risieda in unica copia all'interno di tutto il programma e avevo scelto di utilizzare il Design Pattern Singleton.
Ora, l'ambiente e' multithread quindi mettero' una synchronized sulla classe all'interno del metodo getInstance().
Pero' ho un dubbio; il costruttore privato della classe puo' eseguire delle operazioni? Questa classe infatti avra' delle variabili statiche private ( un timer, un ArrayList ) e appunto avrei bisogno di istanziarle... posso farlo all'interno di questo ?

[andbin]

Originariamente inviato da Poker1
Ora, l'ambiente e' multithread quindi mettero' una synchronized sulla classe all'interno del metodo getInstance().

Non è l'unica strada. Comunque "singleton" vuol solo dire che di quella classe ce ne potrà essere solo 1 istanza. Poi sei tu che devi decidere se fare la istanziazione in modo "lazy" (solo alla prima richiesta) o quando la classe viene caricata dalla JVM.

Nel caso di inizializzazione lazy, c'è una soluzione interessante che evita l'uso di synchronized mantenendo però la thread-safety sfruttando una nested class.

Originariamente inviato da Poker1
Pero' ho un dubbio; il costruttore privato della classe puo' eseguire delle operazioni? Questa classe infatti avra' delle variabili statiche private ( un timer, un ArrayList ) e appunto avrei bisogno di istanziarle... posso farlo all'interno di questo ?

Sì, ovviamente.

[Poker1]

Nel caso di inizializzazione lazy, c'è una soluzione interessante che evita l'uso di synchronized mantenendo però la thread-safety sfruttando una nested class.

Le operazioni che devo fare sono molto veloci quindi sincronizzando il metodo perderei poco tempo, cmq come si attua questa soluzione che mi dici ?

EDIT:
dimenicavo di chiedere una cosa. Siccome i metodi che ho restituiscono un valore, come devo utilizzarli?

String valore = MioTon.getInstance().mioMetodo();

Cosi' chiaramente il compilatore mi da un warning dicendomi che il metodo mioMetodo() deve essere acceduto staticamente, quindi potrei fare:

MioTon ton = MioTon.getInstance();
String valore = MioTon.mioMetodo();

prima creo l'istanza e dopo accedo al metodo? Quale delle due strade? :-)

[andbin]

Ci sono diverse soluzioni, eccole mostrate in dettaglio:


Caso 1)

class Singleton1
{
    private static Singleton1 instance = new Singleton1 ();

    private Singleton1 ()
    {
        // .... blabla ....
    }

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

La istanza del singleton viene creata quando la classe viene caricata dalla JVM. In questo caso il synchronized non serve. La istanza è già creata e basta semplicemente ritornare il reference.


Caso 2)

class Singleton2
{
    private static Singleton2 instance;

    private Singleton2 ()
    {
        // .... blabla ....
    }

    public static synchronized Singleton2 getInstance ()
    {
        if (instance == null)
            instance = new Singleton2 ();

        return instance;
    }
}

La istanziazione del singleton è fatta in modo "lazy" (solo alla prima richiesta). Viene usato il synchronized per poter fare la inizializzazione in modo "atomico", quindi thread-safe.


Caso 3)

class Singleton3
{
    private static class InstanceHolder
    {
        public static Singleton3 instance = new Singleton3 ();
    }

    private Singleton3 ()
    {
        // .... blabla ....
    }

    public static Singleton3 getInstance ()
    {
        return InstanceHolder.instance;
    }
}

Questa è ancora una inizializzazione "lazy" ma non usa synchronized. Sfrutta il fatto che la JVM esegue la inizializzazione dei campi static di una classe in modo "synchronized" una volta sola quando la classe viene caricata.
C'è una classe nested (quindi static) InstanceHolder. Pur essendo dentro la classe Singleton3, non viene caricata nello stesso momento in cui viene caricata Singleton3.
Nel caso sopra, InstanceHolder viene caricata solo quando viene "usata" per la prima volta, cioè quando si chiede il suo campo 'instance'.