Java Singleton et de Synchronisation

Veuillez préciser ma question concernant Singleton et le Multithreading:

  • Quelle est la meilleure façon de mettre en œuvre Singleton en Java, dans un multithread
    de l'environnement?
  • Ce qui se passe lorsque plusieurs threads tentent d'accéder getInstance()
    méthode en même temps?
  • Pouvons-nous faire singleton getInstance() synchronized?
  • Est la synchronisation vraiment nécessaire, lors de l'utilisation d'un Singleton de classes?
InformationsquelleAutor RickDavis | 2012-06-23
  1. 197

    Oui, c'est nécessaire. Il existe plusieurs méthodes que vous pouvez utiliser pour garantir la sécurité des threads avec initialisation:

    Draconiennes de synchronisation:

    private static YourObject instance;

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

    Cette solution nécessite que chaque thread être synchronisé alors qu'en réalité, seuls les premiers ont besoin d'être.

    Vérifiez la synchronisation:

    private static final Object lock = new Object();
private static volatile YourObject instance;

public static YourObject getInstance() {
    YourObject r = instance;
    if (r == null) {
        synchronized (lock) {    //While we were waiting for the lock, another 
            r = instance;        //thread may have instantiated the object.
            if (r == null) {  
                r = new YourObject();
                instance = r;
            }
        }
    }
    return r;
}

    Cette solution garantit que seuls les premiers filets qui essaient d'acquérir votre singleton avoir à passer par le processus d'acquisition de la serrure.

    Initialisation sur Demande:

    private static class InstanceHolder {
    private static final YourObject instance = new YourObject();
}

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

    Cette solution tire parti de la Java du modèle de mémoire garanties sur initialisation de classe pour assurer la sécurité des threads. Chaque classe ne peut être chargée qu'une seule fois, et il va seulement être chargé lorsqu'il est nécessaire. Cela signifie que la première fois getInstance est appelé, InstanceHolder sera chargé et instance sera créé, et puisque c'est contrôlée par ClassLoaders, aucune synchronisation supplémentaire n'est nécessaire.

    • Avertissement soyez prudent avec une double vérification de la synchronisation. Il ne fonctionne pas correctement avec pré-Java 5 Jvm en raison de "problèmes" avec le modèle de mémoire.
    • -1 Draconian synchronization et Double check synchronization getInstance()-méthode doit être statique!
    • Ils n'ont pas besoin pour être static, mais il pourrait faire plus de sens si elles l'étaient. Amendé à la demande.
    • Merci, comment fonctionne un singleton sans statique de lecture?
    • Le même modèle devrait être utilisé pour n'importe quel objet qui a besoin de thread-safe paresseux de l'instanciation.
    • Qu'en est notifyAll() sur la serrure??
    • Pourquoi aurais-je besoin de s'inquiéter à ce sujet? Je ne suis jamais appel wait sur la serrure.
    • Ah, je suis supposé à tort que les autres threads sont en attente alors qu'ils sont en train de le synchronisée(lock), et que notifyAll() est le ce qui est de les réveiller.
    • Quels sont les inconvénients de la dernière méthode? ou, quels sont les avantages des autres sur elle?
    • L'avantage de cette dernière méthode est sa simplicité. Son inconvénient est que vous avez à faire une classe à part. Vous avez un supplément de *.fichier de classe et de la classe de chargement est également pas gratuitement.
    • mais vous pouvez simplement mettre tous dans la même classe, et puis je ne trouve aucun inconvénient. c'est à la demande, thread-safe, très rapide, très facile,...
    • Pour l'initialisation sur la demande de travail, le titulaire de la doit un static intérieur de la classe, sinon il ne fonctionnera pas. Cela va générer un autre *.fichier de classe au moment de la compilation, et une classe de chargement de charge lorsque vous d'abord accéder à votre singleton.
    • Je voulais dire celui qui est appelé "Désireux d'initialisation" sur wikipédia ici: en.wikipedia.org/wiki/Singleton_pattern
    • Ah. Tous les exemples dans ma réponse utiliser les évaluation différée (l'inverse est désireux d'évaluation). l'évaluation différée peut être plus efficace dans le cas où vous ne pourriez pas besoin d'utiliser le singleton.
    • Mais si vous n'utilisez pas le singleton, vous n'atteignez pas le code et l'instance ne sera pas créé, donc c'est un gagnant-gagnant, non? La façon dont je me souviens c'est que dès que vous atteignez la classe singleton (un peu avant la véritable appel à getInstance) , la référence statique est rempli avec la nouvelle instance.
    • Parfois, le pattern singleton est mis en œuvre en tant que partie d'une plus grande et plus complexe de l'objet. Disons qu'un objet a deux tâches principales: la première tâche qui est sans rapport avec le singleton, et de la deuxième tâche. Si vous utilisez un objet pour que la première tâche tout en utilisant désireux d'initialisation, vous perdrez du temps et des ressources de la création de l'singleton qui vous n'utiliserez pas.
    • mais dans les deux cas, vous aurez besoin d'instancier et de gaspillage de temps et de ressources, car vous avez besoin pour effectuer la tâche...
    • Il y a certains cas où il n'est pas une garantie que vous souhaitez utiliser la ressource. Ou peut-être vous voulez retarder l'instanciation de la ressource jusqu'à quand vous en avez besoin afin que vous ayez une plus rapide temps de démarrage.
    • Mais si vous ne l'utilisez pas, pourquoi l'appeler? à droite lorsque vous commencez à l'utiliser, il sera instancié.
    • cela peut être une question stupide, mais où est-ce que votre serrure objet venu?
    • C'est n'importe quel objet que vous souhaitez utiliser.
    • Vous êtes à la mise en œuvre de la double vérification de verrouillage n'est pas garanti de fonctionner. C'est en fait expliqué dans l'article que vous avez cité pour une double vérification de verrouillage. 🙂 Il y a un exemple en utilisant le volatile qui fonctionne correctement pour la 1.5 et supérieur (double vérification de verrouillage est tout simplement cassé en dessous de 1.5). De l'initialisation sur la demande du titulaire également cité dans l'article serait sans doute une solution plus simple dans votre réponse.
    • Je suis au courant. Cependant, je n'ai pas encore d'exécuter une seule instance où j'ai été en cours d'exécution sur quoi que ce soit avant la version 1.6 de Java, de sorte qu'il est sûr de dire qu'elle fonctionne correctement.
    • Je pense que ce lock objet est inutile. Pourquoi ne pas synchroniser sur le YourObject.class lui-même.?
    • parce que n'importe qui peut se synchroniser sur YourObject.class. Il est toujours plus sûr d'utiliser un privé verrouillage de l'objet, car alors vous savez exactement quand et où le moniteur sera saisi
    • pourquoi InstanceHolder doit être une classe à part? public class Foo { private static Foo f = new Foo(); public static Foo getInstance() {return f;} Ce qui est mal à cela?
    • Qui va travailler pour initialisé avec impatience les singletons, mais si vous voulez un paresseusement chargé de singleton, vous voudrez probablement utiliser Initialisation sur Demande
    • Pourquoi avons-nous besoin de "r"? Pourquoi ne pouvons-nous simplement utiliser - public static YourObject getInstance() { if (instance == null) { synchronized (lock) { if (instance == null) { instance = new YourObject(); } } } return instance; } s'il vous Plaît excuser la mise en forme. Ce que j'ai tapé ci-dessus est celui de la réponse de Dan Moldave
    • Autant que je sache, r n'est pas nécessaire pour l'exactitude. C'est juste une optimisation pour éviter l'accès de la volatilité de champ, car c'est beaucoup plus cher que de l'accès à une variable locale.

    InformationsquelleAutor Jeffrey
  2. 64

    Ce modèle fait un "thread-safe" paresseux-initialisation de l'instance sans explicite de la synchronisation!

    public class MySingleton {

     private static class Loader {
         static final MySingleton INSTANCE = new MySingleton();
     }

     private MySingleton () {}

     public static MySingleton getInstance() {
         return Loader.INSTANCE;
     }
}

    Cela fonctionne, car il utilise le chargeur de classe pour faire le tout de la synchronisation pour vous pour gratuit: La classe MySingleton.Loader est d'abord accéder à l'intérieur de la getInstance() méthode, de sorte que le Loader charges de classe quand getInstance() est appelé pour la première fois. En outre, le chargeur de classes garantit que tous initialisation statique est terminée avant que vous obtenez l'accès à la classe - qu'est ce qui vous donne du fil de sécurité.

    C'est comme de la magie.

    C'est en fait très similaire à la enum modèle de Jhurtado, mais je trouve l'enum modèle un abus de l'enum concept (bien qu'il fonctionne)

    • La synchronisation est toujours présent, c'est juste appliqué par la JVM au lieu de par le programmeur.
    • Vous avez raison, bien sûr - j'ai été taper tous (voir les modifications)
    • +1 très bonne réponse
    • Pourquoi ne pas ajouter un explicite "finale" qualificatif à la déclaration de l'INSTANCE? M'a pris un moment pour faire le tri sans elle.
    • Il n'y a rien de faire le tri. C'est une classe privée et rien d'autre n'a accès à lui et c'est initialisée de manière statique. De la rendre définitive, si vous voulez, mais il ne fera aucune différence pour la sécurité ou de comportement.
    • Je comprends qu'il ne fait aucune différence à la JVM, je dis juste qu'il fait une différence pour moi, comme ce qui concerne l'auto-documenté code va. J'ai juste jamais vu tous les bouchons en Java sans le "dernier" mot-clé avant (ou enum), a obtenu un peu de dissonance cognitive. Pour quelqu'un de programmation Java à temps plein, il ne serait probablement pas faire une différence, mais si vous sautez des langues en arrière et en avant, il aide à être explicite. Idem pour les débutants. Bien que, je suis sûr que l'on peut adapter à ce style assez rapide; tous les bouchons est probablement suffisant. Ne veux pas faire la petite bête, j'ai aimé votre post.
    • Excellente réponse, si je n'ai pas une partie de celle ci. Pouvez-vous expliquer "en Outre, le chargeur de classes garantit que tous initialisation statique est terminée avant que vous obtenez l'accès à la classe - qu'est ce qui vous donne du fil de sécurité." comment qui contribue à la sécurité des threads, je suis un peu confus à ce sujet.
    • Pourquoi ne pas static final MySingleton INSTANCE?
    • en fait, bien qu'il n'est pas nécessaire, je suis d'accord pour le style raisons (puisqu'il est en effet finale parce que pas d'autre code peut accéder) final devrait être ajouté. Fait.

    InformationsquelleAutor Bohemian
  3. 21

    Si vous travaillez dans un environnement multithread en Java et la nécessité de garantir à tous les threads accèdent à une seule instance d'une classe, vous pouvez utiliser un Enum. Cela aura l'avantage de vous aider à gérer la sérialisation.

    public enum Singleton {
    SINGLE;
    public void myMethod(){  
    }
}

    et puis juste avoir votre threads de l'utilisation de votre instance comme:

    Singleton.SINGLE.myMethod();
    • Enum approche ne fonctionnera que pour JDK1.5 ou au-dessus.
    InformationsquelleAutor jhurtado
  4. 8

    Oui, vous avez besoin de faire getInstance() synchronisé. Si elle n'est pas là pourraient survenir une situation où de multiples instances de la classe peuvent être faites.

    Considérons le cas où vous avez deux threads appel getInstance() en même temps. Maintenant, imaginez T1 exécute juste après le instance == null vérifier, puis T2 s'exécute. À ce stade de l'instance n'est créée ou d'un ensemble, de sorte T2 va passer la vérification et de créer une instance. Maintenant, imaginez que l'exécution revient à T1. Maintenant, le singleton est créé, mais T1 a déjà fait le chèque! Il procédera à faire de nouveau l'objet! Faire getInstance() synchronisé évite ce problème.

    Il y a quelques façons de faire de singletons thread-safe, mais en faisant getInstance() de synchronisation est probablement le plus simple.

    • Il va les aider en mettant à la création d'objet code Synchronisé bloc, au lieu de faire toute la méthode de synchronisation?
    • Pas de. Vous souhaitez à la fois la case et la création dans le bloc de synchronisation. Vous avez besoin de ces deux opérations se produire sans interruption ou la situation que j'ai décrite ci-dessus peut se produire.
    InformationsquelleAutor Oleksi
  5. 6

    Enum singleton

    La façon la plus simple à mettre en œuvre un Singleton qui est thread-safe est d'utiliser un Enum

    public enum SingletonEnum {
  INSTANCE;
  public void doSomething(){
    System.out.println("This is a singleton");
  }
}

    Ce code fonctionne depuis l'introduction de l'Enum dans Java 1.5

    Une Double vérification de verrouillage

    Si vous voulez un code “classique” singleton qui fonctionne dans un environnement multithread (à partir de Java 1.5), vous devez utiliser celui-ci.

    public class Singleton {

  private static volatile Singleton instance = null;

  private Singleton() {
  }

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

    Ce n'est pas thread-safe avant de 1.5 du fait de la mise en œuvre de mot-clé volatile était différent.

    En charge précoce Singleton (fonctionne même avant de Java 1.5)

    Cette mise en œuvre instancie le singleton lorsque la classe est chargé et assure la sécurité des threads.

    public class Singleton {

  private static final Singleton instance = new Singleton();

  private Singleton() {
  }

  public static Singleton getInstance() {
    return instance;
  }

  public void doSomething(){
    System.out.println("This is a singleton");
  }

}
    InformationsquelleAutor Dan Moldovan
  6. 2

    Vous pouvez également utiliser des bloc de code pour instancier l'instance à la classe de charge et de prévenir le thread des problèmes de synchronisation.

    public class MySingleton {

  private static final MySingleton instance;

  static {
     instance = new MySingleton();
  }

  private MySingleton() {
  }

  public static MySingleton getInstance() {
    return instance;
  }

}
    • Qu'est-ce que MySingletone?
    • C'était une faute de frappe. Modifié
    • Un couple d'autres choses. 1. Vous devriez faire instance finale 2. Vous devriez faire getInstance() statique.
    • Oui je suis d'accord. Merci pour ceux
    • Que feriez-vous si vous voulez créer un thread dans le singleton.
    • l'utilisation d'un pool de threads, un seul pool de threads, si nécessaire, et de l'entourer avec un while(true)-try-catch-throwable si vous voulez vous assurer que votre fils ne meurt jamais, n'importe quelle erreur?

    InformationsquelleAutor usha
  7. 0

    Quelle est la meilleure façon de mettre en œuvre Singleton en Java, dans un environnement multithread?

    Reportez-vous à ce poste pour une meilleure façon de mettre en Singleton.

    Ce qui est un moyen efficace de mettre en œuvre un pattern singleton en Java?

    Ce qui se passe lorsque plusieurs threads tentent d'accéder méthode getInstance() en même temps?

    Il dépend de la façon dont vous avez mis en œuvre la méthode.Si vous utilisez une double verrouillage sans volatils variable, vous pouvez obtenir partiellement construit objet Singleton.

    Reportez-vous à cette question pour plus de détails:

    Pourquoi est volatile utilisée dans cet exemple de la double vérification de verrouillage

    Pouvons-nous faire singleton getInstance() synchronisée?

    Est la synchronisation vraiment nécessaire, lors de l'utilisation d'un Singleton de classes?

    Pas nécessaire si vous mettez en œuvre le Singleton en dessous de moyens

    1. statique intitalization
    2. enum
    3. LazyInitalaization avec Initialisation-sur-demand_holder_idiom

    Reportez-vous à cette question pour plus de détails

    Java Modèle De Conception Singleton : Questions

    InformationsquelleAutor Ravindra babu
  8. 0
    public class Elvis { 
   public static final Elvis INSTANCE = new Elvis();
   private Elvis () {...}
 }

    Source : Efficace Java -> Item 2

    Il suggère de l'utiliser, si vous êtes sûr que la classe sera toujours singleton.

    InformationsquelleAutor Ashish