Modèle Singleton et Singleton en Java
- angryTomavant
- 2019-11-29 13:46:452214parcourir
Avant-propos
Cet article provient de mon compte officiel. Si vous ne l'avez pas vu, jetez-y un oeil. Si vous l'avez fait, vous pouvez y jeter un oeil à nouveau. l'a légèrement modifié. Certains contenus, ce qui est expliqué aujourd'hui est le suivant :
1. Qu'est-ce que le modèle singleton
【 Singleton Pattern], nom anglais : Singleton Pattern, ce modèle est très simple, un type ne nécessite qu'une seule instance, c'est un modèle de conception de logiciel couramment utilisé qui appartient au type de création. Une classe créée via la méthode du mode singleton n'a qu'une seule instance dans le processus en cours (si nécessaire, il peut également s'agir d'un singleton dans un thread, par exemple : seule la même instance est utilisée dans le contexte du thread).
(Vidéo recommandée : tutoriel vidéo Java)
1. Une classe d'instance ne peut avoir qu'une seule instance.
2. La classe singleton doit créer sa propre instance unique.
3. La classe singleton doit fournir cette instance à tous les autres objets.
Alors nous le savons probablement. En fait, pour parler franchement, il n'y aura qu'une seule instance pendant tout le cycle de notre projet. Lorsque le projet s'arrête, l'instance est détruite. Lorsqu'elle est redémarrée, notre. exemple Produits à nouveau.
Ce qui précède mentionne le modèle de conception d'un nom [type de création], alors quel est le modèle de conception du type de création ?
Mode création : responsable de la création d'objets. Nous utilisons ce mode pour créer les instances d'objet dont nous avons besoin.
En plus de la création, il existe deux autres types de motifs :
Modèle structurel (Structural) : gère la combinaison de classes et d'objets
Mode comportemental : Les responsabilités dans l'interaction entre les classes et les objets sont divisées en deux modes de conception :
Nous en reparlerons plus tard, mais je ne les listerai pas ici pour l'instant.
Concentrons-nous sur l'analyse de la façon de créer une instance d'objet en mode singleton à partir de 0.
2. Comment créer un modèle singleton
Il existe de nombreuses façons de mettre en œuvre le modèle singleton : Du "style homme paresseux" au "style homme affamé ", et enfin " Mode "Double vérification du verrouillage", Ici, nous allons expliquer lentement comment créer un singleton étape par étape.
1. Ordre logique normal de pensée
Puisque nous voulons créer une seule instance, nous devons d'abord apprendre à créer une instance. C'est très simple, je pense que tout le monde peut en créer une. exemple, comme Dites quelque chose comme ceci :
/// <summary>
/// 定义一个天气类
/// </summary>
public class WeatherForecast
{
public WeatherForecast()
{
Date = DateTime.Now;
}
public DateTime Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string Summary { get; set; }
}
[HttpGet]
public WeatherForecast Get()
{
// 实例化一个对象实例
WeatherForecast weather = new WeatherForecast();
return weather;
}
Chaque fois que nous visitons, l'heure change, donc nos instances sont toujours créées et changent :
Je pense que tout le monde peut voir ce que ce code signifie. Sans plus tarder, allons droit au but. Nous savons que l'objectif principal du modèle singleton est :
Il est nécessaire de s'assurer que cette instance est unique pendant tout le cycle de fonctionnement du système, afin de s'assurer qu'aucun problème ne surviendra au milieu.
Eh bien, améliorons-nous et améliorons-nous. N'avons-nous pas dit que nous voulions être les seuls ? C'est facile à dire ! Je peux simplement le renvoyer directement :
/// <summary>
/// 定义一个天气类
/// </summary>
public class WeatherForecast
{
// 定义一个静态变量来保存类的唯一实例
private static WeatherForecast uniqueInstance;
// 定义私有构造函数，使外界不能创建该类实例
private WeatherForecast()
{
Date = DateTime.Now;
}
/// <summary>
/// 静态方法，来返回唯一实例
/// 如果存在，则返回
/// </summary>
/// <returns></returns>
public static WeatherForecast GetInstance()
{
// 如果类的实例不存在则创建，否则直接返回
// 其实严格意义上来说，这个不属于【单例】
if (uniqueInstance == null)
{
uniqueInstance = new WeatherForecast();
}
return uniqueInstance;
}
public DateTime Date { get; set; }public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string Summary { get; set; }
}
Ensuite, nous modifions la méthode d'appel, car notre constructeur par défaut a été privatisé et plus aucune instance n'est autorisée à être créée, nous l'appelons donc directement :
[HttpGet]
public WeatherForecast Get()
{
// 实例化一个对象实例
WeatherForecast weather = WeatherForecast.GetInstance();
return weather;
}
Enfin, regardons l'effet :
A ce moment, nous pouvons voir que l'heure n'a pas changé, ce qui signifie que notre instance est unique D'accord, vous avez terminé ! N'es-tu pas très heureux !
Mais ne vous inquiétez pas, voici le problème. Nous sommes actuellement à un seul thread, donc il n'y en a qu'un. Et s'il y a plusieurs threads y accèdent en même temps, est-ce que ce sera normal ?
Ici, nous faisons un test. Lorsque nous démarrons le projet, nous utilisons le multi-threading pour appeler :
[HttpGet]
public WeatherForecast Get()
{
// 实例化一个对象实例
//WeatherForecast weather = WeatherForecast.GetInstance();
// 多线程去调用
for (int i = 0; i < 3; i++)
{
var th = new Thread(
new ParameterizedThreadStart((state) =>
{
WeatherForecast.GetInstance();
})
);
th.Start(i);
}
return null;
}
Ensuite, voyons quel est l'effet selon notre réflexion, cela ne devrait être que. En parcourant le constructeur, ce n'est en fait pas :
3个线程在第一次访问GetInstance方法时，同时判断(uniqueInstance ==null)这个条件时都返回真，然后都去创建了实例，这个肯定是不对的。那怎么办呢，只要让GetInstance方法只运行一个线程运行就好了，我们可以加一个锁来控制他，代码如下：
public class WeatherForecast
{
// 定义一个静态变量来保存类的唯一实例
private static WeatherForecast uniqueInstance;
// 定义一个锁，防止多线程
private static readonly object locker = new object();
// 定义私有构造函数，使外界不能创建该类实例
private WeatherForecast()
{
Date = DateTime.Now;
}
/// <summary>
/// 静态方法，来返回唯一实例
/// 如果存在，则返回
/// </summary>
/// <returns></returns>
public static WeatherForecast GetInstance()
{
// 当第一个线程执行的时候，会对locker对象 "加锁"，
// 当其他线程执行的时候，会等待 locker 执行完解锁
lock (locker)
{
// 如果类的实例不存在则创建，否则直接返回
if (uniqueInstance == null)
{
uniqueInstance = new WeatherForecast();
}
}
return uniqueInstance;
}
public DateTime Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string Summary { get; set; }
}
这个时候，我们再并发测试，发现已经都一样了，这样就达到了我们想要的效果，但是这样真的是最完美的么，其实不是的，因为我们加锁，只是第一次判断是否为空，如果创建好了以后，以后就不用去管这个 lock 锁了，我们只关心的是 uniqueInstance 是否为空，那我们再完善一下：
/// <summary>
/// 定义一个天气类
/// </summary>
public class WeatherForecast
{
// 定义一个静态变量来保存类的唯一实例
private static WeatherForecast uniqueInstance;
// 定义一个锁，防止多线程
private static readonly object locker = new object();
// 定义私有构造函数，使外界不能创建该类实例
private WeatherForecast()
{
Date = DateTime.Now;
}
/// <summary>
/// 静态方法，来返回唯一实例
/// 如果存在，则返回
/// </summary>
/// <returns></returns>
public static WeatherForecast GetInstance()
{
// 当第一个线程执行的时候，会对locker对象 "加锁"，
// 当其他线程执行的时候，会等待 locker 执行完解锁
if (uniqueInstance == null)
{
lock (locker)
{
// 如果类的实例不存在则创建，否则直接返回
if (uniqueInstance == null)
{
uniqueInstance = new WeatherForecast();
}
}
}
return uniqueInstance;
}
public DateTime Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string Summary { get; set; }
}
这样才最终的完美实现我们的单例模式！搞定。
2、幽灵事件：指令重排
当然，如果你看完了上边的那四步已经可以出师了，平时我们就是这么使用的，也是这么想的，但是真的就是万无一失么，有一个 JAVA 的朋友提出了这个问题，C# 中我没有听说过，是我孤陋寡闻了么：
单例模式的幽灵事件，时令重排会偶尔导致单例模式失效。
是不是听起来感觉很高大上，而不知所云，没关系，咱们平时用不到，但是可以了解了解：
为何要指令重排？
指令重排是指的 volatile，现在的CPU一般采用流水线来执行指令。一个指令的执行被分成：取指、译码、访存、执行、写回、等若干个阶段。然后，多条指令可以同时存在于流水线中，同时被执行。
指令流水线并不是串行的，并不会因为一个耗时很长的指令在“执行”阶段呆很长时间，而导致后续的指令都卡在“执行”之前的阶段上。
相反，流水线是并行的，多个指令可以同时处于同一个阶段，只要CPU内部相应的处理部件未被占满即可。比如说CPU有一个加法器和一个除法器，那么一条加法指令和一条除法指令就可能同时处于“执行”阶段, 而两条加法指令在“执行”阶段就只能串行工作。
相比于串行+阻塞的方式，流水线像这样并行的工作，效率是非常高的。
然而，这样一来，乱序可能就产生了。比如一条加法指令原本出现在一条除法指令的后面，但是由于除法的执行时间很长，在它执行完之前，加法可能先执行完了。再比如两条访存指令，可能由于第二条指令命中了cache而导致它先于第一条指令完成。
一般情况下，指令乱序并不是CPU在执行指令之前刻意去调整顺序。CPU总是顺序的去内存里面取指令，然后将其顺序的放入指令流水线。但是指令执行时的各种条件，指令与指令之间的相互影响，可能导致顺序放入流水线的指令，最终乱序执行完成。这就是所谓的“顺序流入，乱序流出”。
这个是从网上摘录的，大概意思看看就行,理解双检锁失效原因有两个重点
1、编译器的写操作重排问题.
例 : B b = new B();
上面这一句并不是原子性的操作,一部分是new一个B对象,一部分是将new出来的对象赋值给b.
直觉来说我们可能认为是先构造对象再赋值.但是很遗憾,这个顺序并不是固定的.再编译器的重排作用下,可能会出现先赋值再构造对象的情况.
2、结合上下文,结合使用情景.
理解了1中的写操作重排以后,我卡住了一下.因为我真不知道这种重排到底会带来什么影响.实际上是因为我看代码看的不够仔细,没有意识到使用场景.双检锁的一种常见使用场景就是在单例模式下初始化一个单例并返回,然后调用初始化方法的方法体内使用初始化完成的单例对象.
三、Singleton = 单例 ？
上边我们说了很多，也介绍了很多单例的原理和步骤，那这里问题来了，我们在学习依赖注入的时候，用到的 Singleton 的单例注入，是不是和上边说的一回事儿呢，这里咱们直接多多线程测试一下就行：
/// <summary>
/// 定义一个心情类
/// </summary>
public class Feeling
{
public Feeling()
{
Date = DateTime.Now;
}
public DateTime Date { get; set; }
}
// 单例注册到容器内
services.AddSingleton<Feeling>();
这里重点表扬下评论区的@我是你帅哥 小伙伴，及时的发现了我文章的漏洞，笔芯！
紧接着我们就控制器注入服务，然后多线程测试：
private readonly ILogger<WeatherForecastController> _logger;
private readonly Feeling _feeling;
public WeatherForecastController(ILogger<WeatherForecastController> logger, Feeling feeling)
{
_logger = logger;
_feeling = feeling;
}
[HttpGet]
public WeatherForecast Get()
{
// 实例化一个对象实例
//WeatherForecast weather = WeatherForecast.GetInstance();
// 多线程去调用
for (int i = 0; i < 3; i++)
{
var th = new Thread(
new ParameterizedThreadStart((state) =>
{
//WeatherForecast.GetInstance();
// 此刻的心情
Console.WriteLine(_feeling.Date);
})
);
th.Start(i);
}
return null;
}
测试的结果，情理之中，只在我们项目初始化服务的时候，进入了一次构造函数：
C'est la même chose que ce que nous avons dit ci-dessus, Singleton est un singleton, et c'est aussi un type de verrouillage à double vérification, car la conclusion peut être vue que lorsque nous utilisons le mode singleton, nous pouvons directement utiliser l'injection de dépendances Sigleton peut suffire et est très pratique.
4. Avantages et inconvénients du mode Singleton
[Excellent], Avantages du mode Singleton :
(1) Assurer l'unicité : empêcher d'autres objets d'être instancié et garantir l'unicité de l'instance ;
(2) Globalité : une fois les données définies, l'instance et les données actuelles peuvent être utilisées n'importe où dans l'ensemble du projet
[Inférieur ; ] Inconvénients du mode singleton :
(1) Mémoire résidente : Parce que le singleton a le cycle de vie le plus long et existe dans l'ensemble du système de développement, si les données sont ajoutées tout le temps ou sont résidentes, cela provoquera un certain quantité de consommation de mémoire.
Le contenu suivant provient de l'Encyclopédie Baidu :
Avantages
1. Contrôle d'instance
Le mode singleton sera empêcher d'autres L'objet instancie sa propre copie de l'objet singleton, garantissant que tous les objets accèdent à l'instance unique.
2. Flexibilité
Étant donné que la classe contrôle le processus d'instanciation, la classe peut modifier le processus d'instanciation de manière flexible.
Inconvénients
1. Overhead
Bien que le nombre soit petit, si une instance de la classe existe à chaque fois que l'objet demande une référence, il y a il y aura encore des frais généraux nécessaires. Ce problème peut être résolu en utilisant l'initialisation statique.
2. Confusion possible dans le développement
Lors de l'utilisation d'objets singleton (en particulier des objets définis dans les bibliothèques de classes), les développeurs doivent se rappeler qu'ils ne peuvent pas utiliser new Le mot-clé instancie les objets. Étant donné que le code source de la bibliothèque peut ne pas être accessible, les développeurs d'applications peuvent se retrouver de manière inattendue dans l'incapacité d'instancier directement cette classe.
3. La durée de vie de l'objet
ne peut pas résoudre le problème de la suppression d'un seul objet. Dans les langages qui assurent la gestion de la mémoire (comme ceux basés sur le .NET Framework), seule une classe singleton peut provoquer la désallocation de l'instance car elle contient une référence privée à l'instance. Dans certains langages (tels que C++), d'autres classes peuvent supprimer des instances d'objet, mais cela entraîne des références pendantes dans la classe singleton.
Cet article provient du site Web php chinois, colonne tutoriel Java, bienvenue pour apprendre !
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!