Une brève introduction au modèle singleton en Java

Cet article présente principalement en détail des informations simples relatives au mode Java singleton, qui ont une certaine valeur de référence. Les amis intéressés peuvent s'y référer

Concept

Le modèle singleton est un modèle de conception de logiciels couramment utilisé. Il ne contient qu’une seule classe spéciale appelée classe singleton dans sa structure de base. Le mode singleton peut garantir qu'il n'y a qu'une seule instance d'une classe dans le système et que l'instance est facilement accessible depuis le monde extérieur, facilitant ainsi le contrôle du nombre d'instances et économisant les ressources du système. Si vous souhaitez qu'un seul objet d'une certaine classe existe dans le système, le modèle singleton est la meilleure solution. À mon avis, un singleton ne permet pas au monde extérieur de créer des objets.

1.1 Analyse conceptuelle

Pour les singletons, à partir de l'analyse conceptuelle ci-dessus, les conditions suivantes doivent être remplies :

Premièrement : il ne peut y avoir qu'un objet singleton

Deuxième : la classe singleton doit créer son propre objet d'instance unique.

Troisièmement : cet objet d'instance est accessible au monde extérieur, et le monde extérieur ne peut pas le créer par lui-même.

2. Plusieurs méthodes courantes du mode singleton

En Java, le mode singleton est généralement divisé en style paresseux et type affamé. mais le type d'enregistrement est généralement moins visible, il est donc facile de l'ignorer. Si l'auteur n'avait pas soudainement voulu le résumer aujourd'hui et n'avait pas cherché des informations sur Internet, je ne l'aurais pas remarqué. Le code est affiché de cette manière et expliqué ci-dessous.

2.1 Classe singleton affamé-chinois

package com.ygh.singleton;
/**
 * 饿汉式单例类
 * @author 夜孤寒
 * @version 1.1.1
 */
public class HungerSingleton {
  //将构造方法私有，外界类不能使用构造方法new对象
  private HungerSingleton(){}
  //创建一个对象
  private static final HungerSingleton lazySinleton=new HungerSingleton();
  //设置实例获取方法，返回实例给调用者
  public static HungerSingleton getInstance(){
    return lazySinleton;
  }
}

Écrivez une classe de test pour tester si le singleton est implémenté :

package com.ygh.singleton;
/**
 * 测试单例类
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class Test {
  public static void main(String[] args) {
    /*
     * 构造方法私有化，不能够使用下面方式new对象
     */
    //HungerSingleton hungerSingleton=new HungerSingleton();
    //使用实例获取方法来获取对象
    HungerSingleton h1=HungerSingleton.getInstance();
    HungerSingleton h2=HungerSingleton.getInstance();
    System.out.println(h1==h2);//true
  }
}

Comme on peut le voir ci-dessus : les deux références de cette classe de test sont égales, ce qui signifie que les deux références pointent vers le même objet, et cela est exactement conforme au modèle singleton standard . Ici se termine l’introduction chinoise affamée.

2.2 Classe singleton affamé-chinois

package com.ygh.singleton;
/**
 * 懒汉式单例类
 * @author 夜孤寒
 * @version 1.1.1
 */
public class LazySingleton {
  //将构造方法私有，外界类不能使用构造方法new对象
  private LazySingleton(){}
  //创建一个对象，不为final
  private static LazySingleton lazySingleton=null;
  //设置实例获取方法，返回实例给调用者
  public static LazySingleton getInstance(){
    //当单例对象不存在，创建
    if(lazySingleton==null){
      lazySingleton=new LazySingleton();
    }
    //返回
    return lazySingleton;
  }
}

Classe de test :

package com.ygh.singleton;
/**
 * 测试单例类
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class Test {
  public static void main(String[] args) {
    /*
     * 构造方法私有化，不能够使用下面方式new对象
     */
    //LazySingleton lazySingleton=new LazySingleton();
    //使用实例获取方法来获取对象
    LazySingleton l1=LazySingleton.getInstance();
    LazySingleton l2=LazySingleton.getInstance();
    System.out.println(l1==l2);//true
  }
}

Comme le montre ce qui précède : les deux références de cette classe de test sont égales, ce qui signifie que les deux références pointent vers le même objet, ce qui est exactement conforme à la norme du modèle singleton. C'est la fin de l'introduction du paresseux.

2.3 La différence entre le style chinois paresseux et le style chinois affamé

Le style chinois paresseux signifie que lorsqu'il n'y a pas d'objet, un objet singleton sera créé. Lorsqu'il y a un objet, aucun objet ne le sera. être créé. , cela n'est peut-être pas si facile à comprendre, mais si les lecteurs souhaitent en savoir plus, ils peuvent utiliser les points d'arrêt dans Eclipse pour tester, ajouter des points d'arrêt au contenu entre les accolades if de la classe LazySingleton, puis dans le Classe de test, utilisez l'opération de débogage, cela peut être facilement reflété. Un objet est créé la première fois, mais aucun objet n'est créé la deuxième fois.

Le style chinois affamé est implémenté en utilisant le mot-clé final pour créer l'objet. Lorsque l'appelant a besoin de l'objet instance, l'instance créée peut être obtenue via la méthode getInstance.

2.4 Classe Singleton enregistrée

L'auteur n'est pas très familier avec la classe singleton enregistrée. J'ai publié un morceau de code sur Internet pour votre propre référence. propre.

import java.util.HashMap;
import java.util.Map;

/**
 * 登记式单例类
 * @author Administrator
 *
 */
public class RegisterSingleton {
 private static Map<String, RegisterSingleton> map = new HashMap<String, RegisterSingleton>();
 static {
  RegisterSingleton single = new RegisterSingleton();
  map.put(single.getClass().getName(), single);
 }

 /*
  * 保护的默认构造方法
  */
 protected RegisterSingleton() {
 }

 /*
  * 静态工厂方法,返还此类惟一的实例
  */
 public static RegisterSingleton getInstance(String name) {
  if (name == null) {
   name = RegisterSingleton.class.getName();
   System.out.println("name == null" + "--->name=" + name);
  }
  if (map.get(name) == null) {
   try {
    map.put(name, (RegisterSingleton) Class.forName(name).newInstance());
   } catch (InstantiationException e) {
    e.printStackTrace();
   } catch (IllegalAccessException e) {
    e.printStackTrace();
   } catch (ClassNotFoundException e) {
    e.printStackTrace();
   }
  }
  return map.get(name);
 }

 /*
  * 一个示意性的商业方法
  */
 public String about() {
  return "Hello, I am RegSingleton.";
 }

 public static void main(String[] args) {
  RegisterSingleton single3 = RegisterSingleton.getInstance(null);
  System.out.println(single3.about());
 }
}

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!