Introduction détaillée au mode singleton en simultanéité (avec code)

Cet article vous apporte une introduction détaillée au mode singleton en simultanéité (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Le processus de création d'objet qui consomme le plus de mémoire doit être contraint. En tant que mode création, le mode singleton (Singleton) maintient toujours qu'il n'y a qu'une et une seule instance d'une certaine instance dans l'application, ce qui peut être très évident. Améliorer considérablement les performances du programme.

Ce qui suit abordera les quatre méthodes d'implémentation de singleton.

 单线程下的Singleton的稳定性是极好的，可分为两大类：

Eager (type impatient) : créez un objet immédiatement lorsque la classe est chargée.

public class EagerSingleton {
    //1. 类加载时就立即产生实例对象，通过设置静态变量被外界获取
    //2. 并使用private保证封装安全性
    private static EagerSingleton eagerSingleton  = new EagerSingleton();
    
    //3. 通过构造方法的私有化，不允许外部直接创建对象，确保单例的安全性
    private EagerSingleton(){
    }
    public static EagerSingleton getEagerSingleton(){
        return eagerSingleton;
    }

2. Lazy (type paresseux) : L'objet n'est pas créé immédiatement lorsque la classe est chargée, et n'est instancié que lorsque le premier utilisateur l'obtient.

public class LazySingleton {
    //1. 类加载时并没有创建唯一实例
    private static LazySingleton lazySingleton;
    
    private LazySingleton() {
    }
        
    //2、提供一个获取实例的静态方法
    public static LazySingleton getLazySingleton() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        } 
        return lazySingleton;
    }

En termes de performances, LazySingleton est évidemment meilleur que EagerSingleton Si le chargement des classes nécessite beaucoup de ressources (par exemple la lecture d'informations sur des fichiers volumineux), alors les avantages de LazySingleton sont évidents. Mais en lisant le code, il est facile de repérer un problème fatal. Comment maintenir la sécurité entre plusieurs threads ?

Le problème de concurrence multithread sera analysé ci-dessous :

La clé pour résoudre ce problème réside dans deux aspects : 1. Synchronisation 2. Performance ; ;

1. Tout d'abord, résolvons le problème de synchronisation : Pourquoi l'exception de synchronisation se produit-elle ? Utilisons un exemple classique comme explication :

Il y a le thread A, et le thread B appelle getLazySingleton() en même temps pour obtenir l'instance. Lorsque A l'appelle, il détermine que. l'instance est nulle. Lors de la préparation de l'initialisation, le thread A a été suspendu à ce moment-là, l'objet n'a pas été instancié avec succès plus tard, et il a également jugé que l'instance était nulle. A et B sont entrés dans la phase d'instanciation, ce qui a abouti à la création de deux instances, violant le principe du singleton.

Comment sauver ?
En tant que développeur Java, vous devez être familier avec synchronisé En matière de multi-threading, la plupart des gens pensent à lui (après JDK6, ses performances se sont grandement améliorées et la solution est. Concurrence simple, très applicable).

Alors utilisons synchronisé pour essayer de le résoudre :

//由synchronized进行同步加锁
public synchronized static LazySingleton getLazySingleton() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        } 
        return lazySingleton;
    }

Le problème de synchronisation semble donc résolu, mais en tant que développeur, le plus important est de s'assurer performances. Il y a des avantages et des inconvénients à utiliser synchronisé. En raison de l'opération de verrouillage, le segment de code est verrouillé de manière pessimiste. Ce n'est que lorsqu'une requête est terminée que la requête suivante peut être exécutée. Habituellement, les morceaux de code avec le mot-clé synchronisé seront plusieurs fois plus lents qu'un code de même ampleur, ce que nous ne voulons pas voir. Alors comment éviter ce problème ? Il y a cette suggestion dans la définition Java de synchronisé : plus vous utilisez synchronisé tard, meilleures sont les performances (verrouillage raffiné).

###### 2. Par conséquent, nous devons commencer à résoudre le problème de performances. Optimiser en fonction de la synchronisation : ######

public class DoubleCheckLockSingleton {
    //使用volatile保证每次取值不是从缓存中取，而是从真正对应的内存地址中取.（下文解释）
    private static volatile DoubleCheckLockSingleton doubleCheckLockSingleton;
    
    private DoubleCheckLockSingleton(){
        
    }
    
    public static DoubleCheckLockSingleton getDoubleCheckLockSingleton(){
        //配置双重检查锁（下文解释）
        if(doubleCheckLockSingleton == null){
            synchronized (DoubleCheckLockSingleton.class) {
                if(doubleCheckLockSingleton == null){
                    doubleCheckLockSingleton = new DoubleCheckLockSingleton();
                }
            }
        }
        return doubleCheckLockSingleton;
    }
}

Le code source ci-dessus est le classique mot-clé volatile (renaît après JDK1.5) + verrouillage à double vérification (DoubleCheck) , dans la plus grande mesure, il optimise les frais généraux de performances causés par la synchronisation. Volatile et DoubleCheck seront expliqués ci-dessous.

1.volatile

a été officiellement implémenté après JDK1.5. Les versions précédentes définissaient uniquement ce mot-clé sans implémentation spécifique. Si vous voulez comprendre volatile, vous devez avoir une certaine compréhension de la propre gestion de la mémoire de la JVM :

1.1 Selon la loi de Moore, la vitesse de lecture et d'écriture de la mémoire ne peut plus satisfaire le processeur, les ordinateurs modernes ont donc introduit un mécanisme pour ajouter un cache au processeur. Le cache prélit la valeur de la mémoire et la stocke temporairement dans le cache. Grâce au calcul, la valeur correspondante dans la mémoire est mise à jour.

**1.2** La JVM imite l'approche du PC et divise sa propre **mémoire de travail** dans la mémoire. Cette partie de la mémoire fonctionne de la même manière que le cache, ce qui améliore considérablement le travail de la JVM. De l'efficacité, mais tout a des avantages et des inconvénients. Cette approche provoque également des problèmes de transmission lorsque la mémoire de travail communique avec d'autres mémoires. Une fonction de volatile est de forcer la lecture de la dernière valeur dans la mémoire pour éviter toute incohérence entre le cache et la mémoire.

1.3 Une autre fonction de volatile est également liée à la JVM, c'est-à-dire que la JVM utilisera son propre jugement pour réorganiser l'ordre d'exécution du code source assurer la cohérence des instructions du Pipeline pour parvenir au plan d'exécution optimal. Cette approche améliore les performances, mais elle produira des résultats inattendus pour DoubleCheck et les deux threads peuvent interférer l'un avec l'autre. Volatile offre une garantie d'occurrence (l'écriture est prioritaire sur la lecture), afin que l'objet ne soit pas perturbé et assure une stabilité sûre.

2.DoubleCheck

Il s'agit d'un héritage de la programmation moderne. On suppose qu'après être entré dans le bloc synchronisé, l'objet a été instancié et le jugement doit être effectué. être refait.

Bien sûr, il existe une autre méthode d'implémentation singleton officiellement recommandée :

Puisque la construction de la classe est déjà atomique dans la définition, tous les problèmes ci-dessus sont résolus. ne sera pas généré à nouveau. C'est une bonne méthode d'implémentation singleton et elle est recommandée.

//使用内部类进行单例构造
public class NestedClassSingleton {
    private NestedClassSingleton(){
        
    }
    private static class SingletonHolder{
        private static final NestedClassSingleton nestedClassSingleton = new NestedClassSingleton();
    }
    public static NestedClassSingleton getNestedClassSingleton(){
        return SingletonHolder.nestedClassSingleton;
    }
}

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!