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關(guān)鍵詞防止指令重排序,下文介紹
	private static volatile Singleton singleton;
	private Singleton(){}
	public static Singleton getInstance() {
	//如果singleton不為空,則直接返回對象,若多個線程發(fā)現(xiàn)singleton為空，則進入分支
		if (singleton == null) {
		//多個線程同時爭搶一個鎖，只有一個線程能成功，其他線程需等待
			synchronized(Singleton.class) {
			//爭搶到鎖的線程需再次判斷singleton是否為空，因為有可能被上個線程實例化了
			//若不為空則實例化,后續(xù)線程再進入的時候則直接返回該對象
			//對于之后所有進入該方法的線程則無需獲取鎖，直接返回對象   
        	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!