Maîtriser complètement le modèle Java singleton

Cet article vous apporte des connaissances pertinentes sur java, qui introduit principalement des problèmes liés au mode singleton, qui fait référence à un mode dans lequel une classe n'a qu'une seule instance, et la classe peut créer cette instance par elle-même, comme suit Prenons jetez-y un coup d'oeil ensemble, j'espère que cela sera utile à tout le monde.

Apprentissage recommandé : "Tutoriel vidéo Java"

Modèle de cas unique :

Tout d'abord, il existe 23 modèles de conception en Java

• Créatif motif : Usine Modèle de méthode, modèle d'usine abstrait, modèle singleton, modèle de constructeur, modèle de prototype
• modèle structurel: modèle d'adaptateur, modèle de décorateur, modèle de proxy, modèle d'apparence, modèle de pont, modèle de composition, modèle de poids mouche
• modèles de type de comportement: : Modèle de stratégie, modèle de méthode modèle, modèle d'observateur, modèle d'itérateur, modèle de chaîne de responsabilité, modèle de commande, modèle de mémo, modèle d'état, modèle de visiteur, modèle de médiateur, modèle d'interprète.

1. Qu'est-ce que le modèle singleton :

Définition :
fait référence à un modèle dans lequel une classe n'a qu'une seule instance, et la classe peut créer cette instance par elle-même. Cela peut éviter le gaspillage de ressources mémoire provoqué par l'ouverture de plusieurs fenêtres du gestionnaire de tâches ou des erreurs telles qu'un contenu d'affichage incohérent dans chaque fenêtre. Par exemple, notre ordinateur ne peut-il avoir qu’un seul gestionnaire de tâches ouvert ? C'est vrai, c'est pour éviter le gaspillage de ressources et d'autres erreurs.

Dans les projets, vous pouvez généralement utiliser le mode singleton pour obtenir le même objet pour appeler des méthodes outils. L'avantage est d'économiser des ressources mémoire. Je n'ai pas besoin de créer plusieurs objets différents, car cela consomme des ressources mémoire.

En bref :

Un singleton signifie que le programme n'a qu'une seule instance. Cette classe est chargée de créer son propre objet. En même temps, elle doit s'assurer qu'il n'y a qu'une seule création d'objet Caractéristiques du singleton. pattern :

Constructeur privé

Détient ses propres attributs de type
1. fournit des méthodes statiques externes pour obtenir des instances
3. Schéma structurel du mode singleton :

2. Avantages et inconvénients du mode singleton :

Avantages :

Utilisation réduite de la mémoire Overhead

Éviter l'occupation multiple des ressources
1. Définir un point d'accès global pour optimiser et partager l'accès aux ressources
3. Inconvénients (référencés depuis Internet) :

Généralement, il n’y a pas d’interface et l’expansion est difficile. Si vous souhaitez développer, il n'y a pas d'autre moyen que de modifier le code d'origine, ce qui viole le principe d'ouverture et de fermeture

Dans les tests simultanés, le mode singleton n'est pas propice au débogage du code. Pendant le processus de débogage, si le code du singleton n'a pas été exécuté, un nouvel objet ne peut pas être simulé. Le code fonctionnel du mode singleton est généralement écrit dans une classe. Si la conception fonctionnelle est déraisonnable, il est facile de violer le. responsabilité unique. Principes
2. Regardez une carte mentale du mode singleton :

3. Mode paresseux (plus couramment utilisé)

La caractéristique du mode paresseux est une initialisation retardée et l'objet ne sera pas instancié. jusqu'à ce que la méthode soit appelée pour obtenir l'instance.

Le thread n'est pas sûr, à proprement parler, ce n'est pas un mode singleton. L'avantage est que l'objet est créé après l'obtention de l'instance, ce qui permet d'économiser de la mémoire.

public class SingLeton {

    //1、有自己类型的属性
    private static SingLeton instance;

    //2、构造器私有化
    private SingLeton(){}

    //3、对外提供获取实例的静态方法
    public static SingLeton getInstance(){
        if (instance == null){
            instance = new SingLeton();
        }
        return instance;
    }}

Classe de test :

public class Test {
    public static void main(String[] args) {

        //判断是否产生的是同一个对象
        SingLeton s1 = SingLeton.getInstance();
        SingLeton s2 = SingLeton.getInstance();
        System.out.println(s1 == s2);
    }}

Sortie :

true

Remarque :

À propos des threads en mode paresseux ne sont pas sûrs

Maintenant, nous savons que les threads en mode paresseux ne sont pas sûrs, vous devez donc à utilisez des verrous (synchronisés) pour synchroniser :

/**
 *   保证 instance 在所有线程中同步
 */public class SingLeton2 {

        //1、有自己类型的属性
        private static volatile SingLeton2 instance ;    
        
        //2、构造器私有化
        private SingLeton2() {
        }

        public static synchronized SingLeton2 getInstance() {
            //getInstance 方法前加同步
            if (instance == null) {
                instance = new SingLeton2();
            }
            return instance;
        }
    }

Si vous écrivez plusieurs threads, ne supprimez pas les mots-clés volatile et synchronisé dans l'exemple de code ci-dessus, sinon il y aura des problèmes de non-sécurité des threads. Si vous ne supprimez pas ces deux mots-clés, vous pouvez garantir la sécurité des threads. Cependant, la synchronisation est requise à chaque fois que vous y accédez, ce qui affectera les performances et consommera plus de ressources.

4. Mode Han affamé [Recommandé]

Le mode Han affamé est thread-safe et couramment utilisé, mais il est facile de générer des objets inutiles, car le mode Han affamé initialise

instances lorsqu'il charge une classe au début

Démo :

/**
 *
 * 饿汉模式
 */public class SingLeton {

    //持有自己类型的属性   (和懒汉一样)
    //由于static修饰，只在类加载的时候执行一次，类加载的时候就实例化对象
    private static SingLeton instance = new SingLeton();

    //构造器私有化，不能通过它创建对象
    private SingLeton(){};

    //对外提供获取实例的静态方法
    public static SingLeton getInstance(){
        return instance;
    }}

Classe de test :

public class Test {
    public static void main(String[] args) {

        //判断是否产生的是同一个对象
        SingLeton s1 = SingLeton.getInstance();
        SingLeton s2 = SingLeton.getInstance();
        System.out.println(s1 == s2);
    }}

Sortie :

true

Comparaison entre le mode paresseux et le mode faim :

1. 懒汉模式延迟加载，非线程安全，饿汉模式线程安全
2. 懒汉模式刚运行不实例化对象，需要的时候才实例化对象，相当于来讲更节省内存开销
3. 饿汉模式只要运行都会加载类的时候就给你初始化了，就需要使用更大的内存

图解：

5、单例模式的应用场景：

1. 需要经常创建的一些类，使用单例可以降低系统的内存压力
2. 这个类只要求生成一个对象的时候，比如每个人的名字
3. 类创建实例时占用资源较多，或实例化耗时较长，且经常使用
4. 频繁访问数据库或文件的对象
5. 类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池

6、单例模式的应用实例

这里使用懒汉式单例模式模拟产生班级的班长
分析： 在每一个学期内，班级的班长只有一人，所以适合用单例模式实现

Person类：

/**
 * 使用懒汉模式
 */public class Person {

    //保证instance在所有线程中同步
    private static volatile Person instance;

    private Person(){
        System.out.println("产生一个班长");
    }

    //加上synchronized锁
    public static synchronized Person getInstance(){
        if(instance == null){
            instance = new Person();
        }else {
            System.out.println("错误信息：已经有一个班长，不能再产生");
        }
        return instance;
    }

    public void getName(){
        System.out.println("我是班长：小强");
    }}

测试类：

public class Test {
    public static void main(String[] args) {

        Person p1 = Person.getInstance();
        p1.getName(); //输出班长名字

        Person p2 = Person.getInstance();
        p2.getName();

        if(p1 == p2){
            System.out.println("两个班长是同一个人");
        }else {
            System.out.println("两个班长是同一个人");

        }
    }}

运行结果：

产生一个班长
我是班长：小强
错误信息：已经有一个班长，不能再产生
我是班长：小强
两个班长是同一个人

小结:

这个就是单例模式，当程序已经产生一个对象后，就不会产生一个新的对象，即使有多个对象也是同一个对象而已，在使用懒汉模式的时候需要注意线程安全问题，在平时更加推荐使用饿汉模式，也需要注意资源的占用。

推荐学习：《java教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!