Comment écrire un modèle java singleton

Singleton Pattern est l’un des modèles de conception les plus simples de Java. Ce type de modèle de conception est un modèle de création qui offre une manière optimale de créer des objets.

Ce modèle implique une seule classe qui est chargée de créer ses propres objets tout en garantissant qu'un seul objet est créé. Cette classe fournit un moyen d'accéder directement à ses objets uniques, sans avoir besoin d'instancier un objet de la classe.

Remarque :

1. Une classe singleton ne peut avoir qu'une seule instance. 2. Une classe singleton doit créer sa propre instance unique. 3. La classe singleton doit fournir cette instance à tous les autres objets.

5 façons d'écrire le mode Java singleton :

1. Mode corsé (mode paresseux)

// 饱汉
// UnThreadSafe
public class Singleton1 {
  private static Singleton1 singleton = null;
  private Singleton1() {
  }
  public static Singleton1 getInstance() {
    if (singleton == null) {
      singleton = new Singleton1();
    }
    return singleton;
  }
}

Avantages. : Le chargement paresseux démarre rapidement, consomme peu de ressources, est instancié lorsqu'il est utilisé et est sans verrouillage.

Inconvénients : Pas thread-safe.

2. Mode paresseux (mode paresseux) - sécurité des threads

public class Singleton {
    /**
     * 定义一个变量来存储创建好的类实例
     */
    private static Singleton uniqueInstance = null;
    /**
     * 私有化构造方法，好在内部控制创建实例的数目
     */
    private Singleton(){
    }
    /**
     * 定义一个方法来为客户端提供类实例
     * @return 一个Singleton的实例
     */
    public static synchronized Singleton getInstance(){
        //判断存储实例的变量是否有值
        if(uniqueInstance == null){
            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
            uniqueInstance = new Singleton();
        }
        //如果有值，那就直接使用
        return uniqueInstance;
    }
    /**
     * 示意方法，单例可以有自己的操作
     */

    public void singletonOperation(){
//功能处理
    }
    /**
     * 示意属性，单例可以有自己的属性
     */
    private String singletonData;
    /**
     * 示意方法，让外部通过这些方法来访问属性的值
     * @return 属性的值
     */
    public String getSingletonData(){
        return singletonData;
    }
}

Avantages : Idem que ci-dessus, mais verrouillé.

Inconvénients : synchronisé est un verrou exclusif et a de mauvaises performances de concurrence. Même une fois la création réussie, l’obtention de l’instance reste une opération sérialisée.

3. Mode paresseux (mode paresseux) - Double Check Lock DCL (Double Check Lock)

public class Singleton {
    /**
     * 对保存实例的变量添加volatile的修饰
     */
    private volatile static Singleton instance = null;
    private Singleton(){
    }

    public static Singleton getInstance(){
//先检查实例是否存在，如果不存在才进入下面的同步块
       if(instance == null){
//同步块，线程安全的创建实例
            synchronized(Singleton.class){
//再次检查实例是否存在，如果不存在才真的创建实例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Avantages : chargement paresseux, sécurité des threads.

Remarque : L'instance doit être modifiée avec le mot-clé volatile pour garantir une initialisation complète.

4. Mode Hungry

public class Singleton {
//4：定义一个静态变量来存储创建好的类实例
//直接在这里创建类实例，只会创建一次
    private static Singleton instance = new Singleton();
//1：私有化构造方法，好在内部控制创建实例的数目
    private Singleton(){
    }
//2：定义一个方法来为客户端提供类实例
//3：这个方法需要定义成类方法，也就是要加static
//这个方法里面就不需要控制代码了
   public static Singleton getInstance(){
//5：直接使用已经创建好的实例
       return instance;
    }
}

Avantages : Le mode Hungry est intrinsèquement thread-safe et il n'y a aucun délai lorsqu'il est utilisé.

Inconvénients : Une instance est créée au démarrage, ce qui ralentit le démarrage et peut entraîner un gaspillage de ressources.

5. Mode support

public class Singleton {
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static Singleton instance = new Singleton();
    }
    /**
     * 私有化构造方法
     */
    private Singleton(){
    }
    public static  Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

Avantages : Une combinaison parfaite de chargement paresseux et de sécurité du fil (pas de verrous). (Recommandé)

Recommandations d'apprentissage associées : Tutoriel de base 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!