Pattern pour instanciation singleton paresseux thread-safe en Java

le paresseux thread-safe singleton
instantion est un peu pas facile à
comprendre pour chaque codeur

Non, c'est vraiment très, très simple:

public class Singleton{
    private final static Singleton instance = new Singleton();
    private Singleton(){ ... }
    public static Singleton getInstance(){ return instance; }
}

Mieux encore, faire un enum:

public enum Singleton{
    INSTANCE;
    private Singleton(){ ... }
}

C'est thread-safe, et il est paresseux (l'initialisation se passe en classe, le temps de chargement, et Java ne permet pas de charger des classes jusqu'à ce qu'ils sont au premier).

Fait est que 99% du temps, vous n'avez pas besoin d'un chargement différé à tous les. Et de le 1% restant, dans 0,9% de la ci-dessus est parfaitement paresseux assez.

Vous avez un profiler et a déterminé que votre application belings pour le 0,01% qui a vraiment besoin de lazy-loading-au-premier-accès? Ne crois pas. Alors, pourquoi perdez-vous votre temps à vous concocter ces Rube Goldbergesque code des abominations pour résoudre un non-problème existant?

Semble overengineered pour moi.

Je ne vois vraiment pas comment le fait d'avoir helper classe aide.

Tout d'abord, c'est à l'aide de double-verrouillage idiome, et il a été prouvé une fois et de nouveau cassé.

Deuxième, si vous ONT POUR utilisation d'un singleton, pourquoi ne pas initialiser static final instance.

public class Singleton1 {
    private static final Singleton1 instanceHolder =
        new Singletong1( );

    public Singleton1 instance() {
        return instanceHolder;
    }

    private Singleton1() {
        System.out.println("Singleton1 instantiated");
    }
}

Ce code est thread-safe et a été prouvée à travailler.

Vérifier Vineet Reynolds réponse lorsque vous avez besoin d'initialiser l'instance du singleton sur une première obtenir. Dans de nombreux cas, je pense que cette approche est trop.

Je suis d'accord avec d'autres affiches et de dire qu'il ne sembler un peu exagéré, mais ont dit que je pense que c'est quelque chose que développeur junior est susceptible de se tromper. Je pense que, parce que le comportement du fournisseur qui construit le singleton (voir ci-dessous) est la même dans presque tous les cas, je serais tenté de mettre ce que le comportement par défaut dans le LazyThreadSafeInstantiator. L'utilisation de la annonomous intérieur de la classe à chaque fois que vous souhaitez utiliser un singleton est vraiment salissant.

        @Override
        public Singleton1 get() {
            return new Singleton1();
        }

Ce qui pourrait être fait en fournissant une surcharge du constructeur qui prend la Classe singleton nécessaire.

public class LazyThreadSafeInstantiator<T> implements Supplier<T> {
    private final Supplier<T> instanceSupplier;

    private Class<T> toConstruct;

    private volatile T obj;

    public LazyThreadSafeInstantiator(Supplier<T> instanceSupplier) {
        this.instanceSupplier = instanceSupplier;
    }

    public LazyThreadSafeInstantiator(Class<t> toConstruct) {
        this.toConstruct = toConstruct;
    }

    @Override
    //http://en.wikipedia.org/wiki/Double-checked_locking
    public T get() {
        T result = obj;  //Wikipedia: Note the usage of the local variable result which seems unnecessary. For some versions of the Java VM, it will make the code 25% faster and for others, it won't hurt.
        if (result == null) {
            synchronized(this) {
                result = obj;
                if (result == null) {
                    if (instanceSupplier == null) {
                      try {
                        Constructor[] c = toConstruct.getDeclaredConstructors();
                        c[0].setAccessible(true);
                        result = c[0].newInstance(new Object[] {});
                      } catch (Exception e) {
                        //handle
                      }
                      result = 
                    } else {
                      result = instanceSupplier.get();
                    }
                    obj = result;
                }
            }
        }
        return result;
    }
}

Ce serait alors utilisé comme.

private static final Supplier<Singleton1> instanceHolder =
    new LazyThreadSafeInstantiator<Singleton1>(Singleton1.getClass());

C'est à mon avis est un peu plus propre. Vous pourriez alos étendre cette suite à l'utilisation des arguments du constructeur.