Une brève discussion sur plusieurs modèles de conception courants en Java : le modèle singleton

1. Modèle Singleton

C'est l'un des modèles de conception les plus couramment utilisés en Java. Sa structure de base ne contient qu'une classe spéciale appelée singleton. Le modèle singleton peut garantir qu’il n’existe qu’une seule instance de la classe qui applique ce modèle dans le système.

2. Exigences du modèle

1. Votre propre méthode de construction doit être privée

2 Créez votre propre instance unique à l'intérieur de la classe

3, fournissez. une méthode statique publique pour que d'autres objets obtiennent l'instance

3. Plusieurs méthodes d'implémentation

Style chinois affamé

public class Simple {
private static Simple simple = new Simple();
private Simple() {
}
public static Simple getInstance() {
return simple;
}
}

Cette méthode d'implémentation est dans la classe Instanciation au chargement temps, pas de chargement paresseux, thread-safe.

Lazy Man Style

public class Slacker {
private static volatile Slacker slacker = null;
private Slacker() {
}
/**
* 最简单的懒汉式实现
* @return
*/
public static Slacker getInstance() {
if(slacker == null) {
slacker = new Slacker();
}
return slacker;
}
}

Cette implémentation est l'implémentation la plus basique. Le plus gros problème est qu'elle ne prend pas en charge le multi-threading. La méthode d'accès simultané obtiendra plus d'une instance, donc à proprement parler, ce n'est pas un modèle Singleton.

public class Slacker {
//volatile关键字的作用
//1、保证内存可见性:保证每个线程访问volatile修饰的共享变量时获取到的都是最新的。
//2、防止指令重排序--通过内存屏障实现
private static volatile Slacker slacker = null;
private Slacker() {
}
/**
* 加synchronized关键字解决线程同步问题
* @return
*/
public static synchronized Slacker getInstanceSync() {
if(slacker == null) {
slacker = new Slacker();
}
return slacker;
}
}

Cette méthode d'ajout de verrous synchronisés aux méthodes peut résoudre le problème de l'accès simultané par les threads et implémenter des singletons. Cependant, l'ajout de verrous affectera l'efficacité, elle n'est donc souvent pas utilisée de cette façon.

Verrouillage à double vérification

public class Slacker {
//volatile关键字的作用
//1、保证内存可见性:保证每个线程访问volatile修饰的共享变量时获取到的都是最新的。
//2、防止指令重排序--通过内存屏障实现
private static volatile Slacker slacker = null;
private Slacker() {
}
/**
* 双重检查锁解决线程同步问题
* @return
*/
public static Slacker getInstanceDoubleLock() {
if(slacker == null) {
synchronized (Slacker.class) {
if(slacker == null) {
slacker = new Slacker();
}
}
}
return slacker;
}
}

Cette méthode utilise un mécanisme de double verrouillage, qui peut s'adapter à l'accès simultané multithread et maintenir des performances élevées.

Implémentation de classe interne statique

/**
* 静态内部类方式实现单例模式
*
* 当StaticInnerClass第一次被加载时，并不需要去加载StaticInnerClassHoler，只有当getInstance()方法第一次被调用时，
* 才会去初始化staticInnerClass,第一次调用getInstance()方法会导致虚拟机加载StaticInnerClassHoler类，这种方法不仅能
* 确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。
*
* @author chenf
*
*/
public class StaticInnerClass {
private StaticInnerClass() {
}
// 静态内部类
private static class StaticInnerClassHoler {
// 在静态内部类中定义外部类的实例
private static StaticInnerClass staticInnerClass = new StaticInnerClass();
}
/**
* 获取时调用静态内部类的类属性获取外部类的实例
*
* @return
*/
public static StaticInnerClass getInstance() {
return StaticInnerClassHoler.staticInnerClass;
}
}

Cette méthode peut non seulement obtenir un accès sécurisé multithread, mais également utiliser le mécanisme de chargement de classe interne pour obtenir un chargement paresseux.

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!