Singleton résumé écrit couramment

introduction

« façons de X pour créer un motif de singleton » sur Internet a été la rue pourrie, mais tant de façons, ma mémoire augmentera le fardeau, donc dû faire une comparaison, la connaissance concentrée au sujet de la liste finale des trois plus commune processus ( en fait deux, seule énumération de classe interne statique et aucun problème, le sujet est double verrouillage dangers cachés , voir ci - après le traitement attaque antireflets a)

Comparaison des trois méthodes

Si vous voulez le chargement paresseux:

Je recommande les classes internes statiques, parce que moins de détails, simple, écriture, pas mal facile.

Si vous ne voulez pas le chargement à:

énumération recommandée, est livré avec anti-reflet et l'attaque d'attaque anti-sérialisation, l'écriture simple.

Revérifié libellé de verrouillage

public class DOUBLE_CHECK_LOCK_TEST {
    private volatile static DOUBLE_CHECK_LOCK_TEST Instance = null;
    
    private DOUBLE_CHECK_LOCK_TEST(){}
    
    public static DOUBLE_CHECK_LOCK_TEST getInstance(){
        if(Instance == null){
            synchronized (DOUBLE_CHECK_LOCK_TEST.class){
                if(Instance == null){
                    Instance = new DOUBLE_CHECK_LOCK_TEST();
                }
            }
        }
        return Instance;
    }
}

Deux points clés, une instruction réarrangement éviter volatile, est synchronisé à la classe deux verrouillables

Pourquoi revérifié verrouillage ajouter volatile

Parce que l'instance = new Point (200,1), cette phrase est l'instruction atomique, en fait, il y a trois étapes:

1. objets alloués;

2. Appelez le constructeur, pour effectuer l'initialisation;

3. La référence d'objet attribué à la variable.

2 et 3 , dans lequel le réarrangement d'instruction peut se produire dans un environnement concurrent, un thread peut d' abord effectuer un 1 et 3, puis juste commuté sur le fil B, puis enfilez B verra un pas nul, mais n'a pas terminé l'initialisation objet, puis thread B accède à l'exception de l' objet se produit. (Voir détail double contrôle verrouille Singleton Pourquoi utiliser le mot - clé volatile? )

libellé des classes internes statiques

public class STATIC_TEST {
    private static class STATIC_HOLDER{
        private static final STATIC_TEST Instance = new STATIC_TEST();
    }
    STATIC_TEST(){}
    public static final STATIC_TEST getInstance(){
        return STATIC_HOLDER.Instance;
    }
}

libellé Enumération

enum  ENUM_TEST {
    SINGLETON;
    public void doSomething() {
        System.out.println("doSomething");
    }
}

traitement d'attaque anti-sérialisation

De plus la méthode readResolve () de la classe dans un seul mode de réalisation.

private Object readResolve(){
        return Instance;
    }

Anti-reflet traitement d'attaque

Ajout d'une vérification dans le constructeur. Si vous trouvez que vous avez créé avant, il ne se crée plus. Pour vérifier que la serrure comme exemple:

private DOUBLE_CHECK_LOCK_TEST(){
        if(Instance != null){
            System.out.println("发现反射攻击，不许创建新实例！");
            throw new IllegalStateException();
        }
    }

Mais dans les « Java Singleton --- attaques de réflexion Singleton et des solutions », l'article a souligné:

Si la première instance acquise par des moyens normaux d'accès, puis réfléchi attaquer un exemple, et cette réflexion a été maintenue peut prévenir les attaques.

Mais si, à son tour, reflète la première attaque Obtient une instance, puis obtenir une instance par les moyens normaux d'accès, des résultats différents de deux . En d' autres termes, une double vérification de la serrure, ce processus ne peut toujours pas prévenir les attaques de réflexion, un certain blog est en ligne faux.

Une autre tentative d'adresse se reflète cette attaque: les attributs d'identification qui ajoutent un seul mode de réalisation, si après instanciation, changement d'identité, le changement est déterminé dans les identifie constructeur Lancers l'intérieur et au- dessus de cet élan presque, mais inutile , les réflexions peuvent libérer le constructeur de l' autorité, l'attribut d'autorité peut également être libéré, et de modifier une valeur d'attribut, cette approche n'est pas acceptable .

Cependant, un tel processus dans une classe interne statique, mais ne produit pas la « première réflexion attaque un exemple, par exemple réacquisition acquis par des moyens normaux, l'objet ci - dessus double verrouillage apparaît différent en résulte deux situations ».

STATIC_TEST(){
        if(STATIC_HOLDER.Instance != null){
            System.out.println("发现反射攻击，不许创建新实例！");
            throw new IllegalStateException();
        }
    }

Je n'ai pas encore à comprendre les raisons spécifiques, veulent voir des amis peuvent y répondre.

référence

Pourquoi serrures à double vérification singleton pour utiliser le mot-clé volatile?

Java Singleton --- attaques de réflexion Singleton et solutions