Introduction détaillée au modèle singleton

Tout d'abord, jetons un coup d'œil à la définition du modèle singleton :

Le modèle singleton est l'un des modèles de conception les plus simples en Java et est un modèle de création qui fournit la meilleure façon de créer des objets. Le modèle singleton implique une seule classe chargée de créer ses propres objets tout en garantissant qu'un seul objet est créé.

(Tutoriel recommandé : Tutoriel d'introduction à Java)

Afin de vous assurer qu'il n'y a qu'un seul objet en mémoire, évitez la création fréquente d'objets qui entraînent une consommation de mémoire, afin que tout cet objet singleton soit utilisé partout où cet objet doit être appelé.

Examinons ensuite les types de modèles singleton :

1. Style paresseux

Le style paresseux signifie que le singleton ne sera créé que lorsqu'il est nécessaire.

Implémentation paresseuse du modèle singleton :

public class Singleton {
	private static Singleton singleton;
	private Singleton(){
	
	}
	public static Singleton getInstance(){
		if (singleton == null) {
			singleton = new Singleton();
	    }
	    return singleton;
}

Il y a un problème avec l'implémentation paresseuse du singleton, c'est-à-dire comment s'assurer qu'un seul objet est créé ? Si deux threads ou plus déterminent que le singleton est vide en même temps, plusieurs objets seront créés. Nous devons donc résoudre le problème de sécurité des threads.

En matière de sécurité des threads, ce qui me vient à l'esprit est le verrouillage. Le verrouillage n'est rien de plus que le verrouillage d'une méthode ou d'un objet de classe.

//在方法上加锁
public class Singleton {
	private static Singleton singleton;
	private Singleton(){}
	public static synchronized Singleton getInstance() {
    	if (singleton == null) {
        	singleton = new Singleton();
    	}
    return singleton;
	}
}

//在类对象上加锁
public class Singleton {
	private static Singleton singleton;
	private Singleton(){}
	public static Singleton getInstance() {
    synchronized(Singleton.class) {   
        if (singleton == null) {
            singleton = new Singleton();
        }
    }
    return singleton;
	}	
}

Ces deux méthodes peuvent résoudre le problème de la création multi-thread d'objets singleton en même temps, mais chaque fois que vous obtenez l'objet, vous devez d'abord acquérir le verrou et les performances de concurrence sont médiocres. Par conséquent, une optimisation est toujours nécessaire. L'objectif de l'optimisation est le suivant : s'il n'y a pas d'objet instancié, verrouillez-le et créez-le. S'il y a un objet instancié, revenez-le directement.

(Recommandation vidéo d'apprentissage : cours java )

Pour le verrouillage sur les méthodes, le verrouillage est requis, qu'il existe ou non un objet instancié. Par conséquent, ce que nous devons optimiser, c'est verrouiller l'objet de classe.

//DCL单例模式（Double Check + Lock）
public class Singleton {
	//volatite关键词防止指令重排序,下文介绍
	private static volatile Singleton singleton;
	private Singleton(){}
	public static Singleton getInstance() {
	//如果singleton不为空,则直接返回对象,若多个线程发现singleton为空，则进入分支
		if (singleton == null) {
		//多个线程同时争抢一个锁，只有一个线程能成功，其他线程需等待
			synchronized(Singleton.class) {
			//争抢到锁的线程需再次判断singleton是否为空，因为有可能被上个线程实例化了
			//若不为空则实例化,后续线程再进入的时候则直接返回该对象
			//对于之后所有进入该方法的线程则无需获取锁，直接返回对象   
        	if (singleton == null) {
           		singleton = new Singleton();
        	}
    		}
		}
    	return singleton;
	}	
}

Le mot-clé volatile est ajouté au code ci-dessus pour empêcher la réorganisation des instructions.

2. Style chinois affamé

Le style chinois affamé signifie que l'objet singleton est créé lorsque la classe est chargée.

Implémentation du modèle singleton de style chinois affamé :

public class Singleton {
	private static final Singleton singleton = new Singleton();
	private Singleton(){
	
	}
	public static Singleton getInstance(){
		return singleton;
	}

Résumé :

Style Lazy Man : instancier des objets uniquement en cas de besoin En développement, si les besoins en mémoire sont élevés, c'est-à-dire. En utilisant le style paresseux, dans un environnement multithread, vous devez utiliser le mode singleton DCL. L'utilisation du mode singleton DCL résout les problèmes de sécurité de concurrence et de faibles performances. Si vous ajoutez le mot-clé volatile, cela peut également empêcher les exceptions NPE causées par. réorganisation des instructions.

Style chinois affamé : l'objet a déjà été instancié lors du chargement de la classe. Si les besoins en mémoire ne sont pas élevés, utilisez le style chinois affamé. Il est simple, n'est pas sujet aux erreurs et n'en contient pas. problèmes de sécurité et de performances de concurrence.

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!