Méthodes de mise en œuvre et méthodes d'écriture courantes du modèle Java singleton

1. Mode Hungry

Le mode Hungry est également appelé mode de préchargement. Il crée et initialise directement un objet singleton lorsque la classe est chargée, il n'a donc pas de problèmes de sécurité des threads. Il s'appuie sur le mécanisme de classe ClassLoader et n'est chargé qu'une seule fois au démarrage du programme, il n'y a donc aucun problème de sécurité des threads. Son code d'implémentation est le suivant :

public class Singleton {
    // 1.防止外部直接 new 对象破坏单例模式
    private Singleton() {}
    // 2.通过私有变量保存单例对象
    private static Singleton instance = new Singleton();
    // 3.提供公共获取单例对象的方法
    public static Singleton getInstance() {
        return instance;
    }
}

Avantages : Implémentation simple, aucun problème de sécurité des threads. Inconvénient : L'objet est créé lors du chargement de la classe. S'il n'est pas utilisé après la création, cela entraînera un gaspillage de ressources.

2. Mode paresseux

Le mode paresseux et le mode affamé sont exactement le contraire. Le mode dit paresseux est le chargement paresseux (lazy chargement), ce qui signifie qu'il ne sera initialisé que lors de sa première utilisation

Le code d'implémentation est le suivant :

public class Singleton {
    // 1.防止外部直接 new 对象破坏单例模式
    private Singleton() {}
    // 2.通过私有变量保存单例对象
    private static volatile Singleton instance = null;
    // 3.提供公共获取单例对象的方法
    public static Singleton getInstance() {
        if (instance == null) { // 第一次效验
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次效验
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Le mode paresseux utilise des verrous de validation doubles et volatiles pour garantir la sécurité des threads Comme le montre le code ci-dessus, qu'il s'agisse du mode affamé ou du mode paresseux, leur. implémentation Les étapes sont les mêmes :

• Créez un constructeur privé pour empêcher d'autres appels d'utiliser directement de nouveaux objets, afin que l'objet créé ne soit pas un objet singleton.

• Créez une variable privée pour contenir l'objet singleton.

• Fournissez une méthode publique pour renvoyer un objet singleton.

Par rapport au mode affamé, le mode paresseux n'entraînera pas de gaspillage de ressources, mais la méthode d'écriture est plus compliquée.

3. Classe interne statique

La classe interne statique peut assurer à la fois la sécurité des threads et le chargement paresseux Elle chargera et initialisera uniquement la classe statique interne via le mécanisme ClassLoader lorsqu'elle est appelée, il s'agit donc d'un thread Safe, le. Le code d'implémentation de ce mode est le suivant :

public class Singleton {
    // 1.防止外部直接 new 对象破坏单例模式
    private Singleton() {
    }
    // 2.静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    // 3.提供公共获取单例对象的方法
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

4. Enumération

L'énumération ne sera chargée et initialisée par la machine virtuelle Java que lors de sa première utilisation, elle est donc également thread-safe et est paresseuse. chargement, son code d'implémentation est le suivant :

public enum  EnumSingleton {
    INSTANCE;
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}

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!