singleton et public static variable Java

J'ai 2 options:

  1. Le Pattern Singleton 
    class Singleton{
    private static Singleton singleton = null;

    public static synchronized Singleton getInstance(){
        if(singleton  == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}
  2. à l'aide d'un static final champ 
    private static final Singleton singleton = new Singleton();

public static Singleton getSingleton() {
    return singleton;
}

Quoi la différence? (single thread ou multithread)

Mises à jour: je suis au courant du projet de Loi Pugh ou enum méthode.
Je ne suis pas la recherche de la bonne façon, mais je ne l'ai utilisé 1. Est-il vraiment une différence b/w 1 ou 2?

Après la mise à jour de votre question pas de différence.
cette question n'a rien à voir avec singleton. vous vous posez au sujet de l'accès à un champ statique de synchroniser ou non synchronisé avec le contexte. modifier les balises s'il vous plaît.
Je suis en désaccord que la première option de verrouillage de chaque thread qui tente de récupérer l'instance et est donc légèrement moins performant.
ses pas une bonne pratique à utiliser synchronized un tous votre méthode. synchronized mise en œuvre est très cher. J'ai posté en vertu d'autres de meilleur moyen d'utiliser un Singleton pour le multithreading

OriginalL'auteur Achow | 2012-12-05

  1. 10

    La principale différence est que, avec la première option , le singleton ne seront initialisées lors de la getInstance est appelé, alors qu'avec la deuxième option, il sera initialisé dès que le contenant de classe est chargé.

    D'un tiers (de préférence) en option, qui est paresseux et thread-safe est d'utiliser un enum:

    public enum Singleton {
    INSTANCE;
}
    Mon erreur ,en quelque sorte manqué. La mis à jour de question maintenant. Aussi, je suis conscient de l'ENUM instance du singleton, je voulais juste savoir la différence b.w le 2, mais merci quand même!

    OriginalL'auteur assylias

  2. 2

    Il y a une différence:

    Solution 1 est un paresseux de l'initialisation, l'instance du singleton sera créé sur le premier invoquer de getInstance

    La Solution 2 est un désireux de l'initialisation, l'instance du singleton sera créé lorsque la classe loades

    Ils sont thread-safe, l'appel de la deuxième multithread est un peu trompeur

    Eh bien, je n'ai pas mis dans le multi-thread bits.Il a été édité..:P

    OriginalL'auteur Aviram Segal

  3. 2

    Le 1er solutions semble être lazier, mais en fait non.

    Une classe est initialisée quand une méthode statique/champ est accessible pour la 1ère fois.

    Il est probable que getInstance() est la seule accessible au public méthode statique de la classe. C'est le point de singleton.

    Puis la classe est initialisée lorsque quelqu'un appelle getInstance() pour la 1ère fois. Cela signifie que les deux solutions sont essentiellement les mêmes dans la paresse.

    Bien sûr, la 2e solutions regarde mieux et plus performant.

    Paresseux, aucune instance du Singleton en cours de création jusqu'à getInstance() est appelée explicitement. La classe sera bien évidemment être chargé à chaque fois. Ou ai-je raté quelque chose?
    dans la 2ème solution, l'instance n'est créé que lorsque la classe est initialisée; la classe est initialisée uniquement lorsqu'une méthode statique/champ est accessible, c'est à dire, lorsque getInstance() est invoquée.

    OriginalL'auteur irreputable

  4. 1

    Donc, avec la mise à jour des deux options ci-dessus sont thread-safe. Cependant, le synchronized option exige que chaque thread qui appelle instance pour acquérir ce verrou réduisant ainsi les performances, si cela est fait beaucoup. Aussi, à l'aide de synchronized au niveau de la méthode a le potentiel d'émission de l'aide à la disposition du public de verrouillage (la classe elle-même) qu'en conséquence, si un thread, il acquiert ce verrou (qu'il le pouvait), vous pourriez vous retrouver avec blocage. Le static final option est plus performant mais ne fait pas d'initialisation du singleton (ce qui pourrait ne pas être un problème selon le système).

    Une autre option qui permet de thread-safe paresseux init du Singleton est comme suit:

     public class MySingleton{
      private static class Builder{
          private static final MySingleton instance = new MySingleton();
      }

      public static MySingleton instance(){
           return Builder.intance;
      }
 }

    Cela fonctionne parce que la statique à l'intérieur de la classe est garantie d'être initialisé avant n'importe quelle méthode de la classe conteneur est exécutée.

    -1 électeur, soin de préciser le raisonnement?
    Je viens de relire la réponse, et il n'a pas le problème j'ai pensé qu'il avait. Désolé combat. 🙂 Supprimé mon -1. La réponse ressemble un peu à une salade de mots pour moi, si...et touche à peine sur la vraie différence (paresseux vs désireux d'initialisation). Vous mentionnez la performance et de blocage, mais ceux qui ne sont pas la principale différence.

    OriginalL'auteur John B

  5. -1

    Singleton mise en œuvre en Java (si vous voulez vraiment un) peut être effectuée d'une façon plus élégante que vous avez décrite, pour à la fois désireux et l'initialisation tardive. Vérifier l'enum façon décrit par Joshua Bloch et la solution SingletonHolder proposé par le projet de Loi Pugh, respectivement.

    L'article de wikipédia est aussi un bon point de départ pour la compréhension du modèle et de ne répondre à votre question.

    Ne pas répondre à la question. Si vous voulez suggérer une meilleure façon, c'est très bien...mais au moins répondre à la question posée alors que vous le faites.
    Oui, vous avez raison...

    OriginalL'auteur Costi Ciudatu