java的单例模式的一个问题

Question

java单例模式下面两种方法有什么区别？

方法一：

public class SingleTon {

private static SingleTon singleTon;

private SingleTon(){
}

public synchronized  static SingleTon getSingleTon(){
    if(singleTon == null){
        singleTon = new SingleTon();
    }
    return singleTon;
}

}

方法二：

public class SingleTon {

private static SingleTon singleTon = new SingleTon();

private SingleTon(){
}

public synchronized static SingleTon getSingleTon(){
    return singleTon;
}

}

请教一下这两种方法的区别是什么，哪个更好？

Answer 1

La deuxième méthode est meilleure car la première méthode utilise la concurrence et consomme des performances.

Answer 2

C’est le mode paresseux et le mode affamé. Pour faire simple, c’est un chargement paresseux. Je ne peux pas dire si ce genre de chose est bon ou pas, cela dépend de la scène réelle.

Answer 3

La méthode 2 prépare uniquement à la concurrence, c'est-à-dire qu'elle prend en compte l'acquisition simultanée d'objets singleton. L'utilisateur de cette classe décide s'il y aura un accès simultané.
Ces deux types ont chacun leurs propres avantages et inconvénients. La première méthode est rapide à charger, mais plus lente à obtenir l'objet singleton, car si le jugement est utilisé, le nouvel objet est récupéré pendant l'exécution. La deuxième méthode est plus lente à charger la classe, mais plus rapide à obtenir. Étant donné que les membres statiques sont initialisés lorsque la classe est chargée, votre deuxième méthode n'a pas besoin d'être synchronisée, car vous renvoyez simplement une référence à l'objet et n'impliquez pas le nouvel objet

.

Answer 4

Ce sont les deux méthodes de conception du mode singleton.Les deux utilisent la synchronisation pour éviter les problèmes de concurrence et de sécurité des threads, mais la première est une méthode de conception pour un homme paresseux et la seconde est une méthode de conception pour un homme affamé. impact sur le programme lui-même. La différence est que le moment où l'objet est obtenu est différent

Answer 5

Concernant le mode singleton, il existe en fait 5 façons :

1. Le mode Lazy correspond à votre premier code. L'avantage est : un chargement retardé. L'inconvénient est : une synchronisation de verrouillage est requise à chaque fois que vous obtenez une instance, ce qui gaspille des ressources.

2. Le mode Hungry, correspondant à votre deuxième code, a l'avantage d'être thread-safe, mais a l'inconvénient de se charger dès son apparition, ce qui gaspille des ressources.

3. Mode paresseux de verrouillage à double vérification.

4. Mode paresseux pour les classes internes statiques.

5. Dans Effective Java, il est recommandé d'utiliser enum pour implémenter des singletons.

Answer 6

La différence entre les deux est que la première méthode est un chargement paresseux. Si cette méthode n'est pas appelée, aucun objet ne sera généré, tandis que cette dernière générera une instance lors du chargement de la classe, qu'elle soit utilisée ou non.
La méthode de chargement paresseux la plus typique devrait être comme ceci

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

Cela fait gagner du temps et ne crée pas de nouveaux objets.
De plus, si la simultanéité est très élevée, vous pouvez utiliser volatile pour modifier l'instance.

------------------------Je n'ai pas regardé attentivement votre code, je vais donc ajouter quelque chose de plus------ ----

J'ai découvert que vous avez placé un verrou de synchronisation sur la méthode getInstance. Ceci est totalement inutile. La synchronisation n'est requise que lors de sa première création. La synchronisation ultérieure est une perte de temps totale.