Explication détaillée d'exemples de modèles Java singleton

Cet article présente principalement les informations pertinentes d'exemples détaillés du mode java singleton. J'espère que cet article pourra aider tout le monde à bien comprendre et maîtriser cette partie du contenu. Les amis dans le besoin peuvent se référer à

. java singleton Explication détaillée des exemples de modèle d'exemple

Concept : 　　

Le modèle singleton en Java est un modèle de conception courant. Il en existe trois. types de modèles singleton. : Il existe trois types : singleton de style paresseux, singleton de style affamé et singleton de style enregistrement. ​

Le mode singleton présente les caractéristiques suivantes :

　1. Une classe singleton 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.

Le modèle singleton garantit qu'une classe n'a qu'une seule instance, s'instancie et fournit cette instance à l'ensemble du système. Dans les systèmes informatiques, les pools de threads, les caches, les objets de journal, les boîtes de dialogue, les imprimantes et les objets pilotes de carte graphique sont souvent conçus comme des singletons. Ces applications disposent toutes plus ou moins des fonctionnalités de gestionnaires de ressources. Chaque ordinateur peut avoir plusieurs imprimantes, mais il ne peut y avoir qu'un seul spouleur d'imprimante pour empêcher que deux travaux d'impression ne soient envoyés simultanément sur l'imprimante. Chaque ordinateur peut avoir plusieurs ports de communication, et le système doit gérer ces ports de communication de manière centralisée pour empêcher qu'un port de communication soit appelé par deux requêtes en même temps. En bref, le but du choix du mode singleton est d'éviter les états incohérents et d'éviter les politiques à long terme.

Tout d’abord, examinons une implémentation singleton classique.

public class Singleton {
  private static Singleton uniqueInstance = null;

  private Singleton() {
    // Exists only to defeat instantiation.
  }

  public static Singleton getInstance() {
    if (uniqueInstance == null) {
      uniqueInstance = new Singleton();
    }
    return uniqueInstance;
  }
  // Other methods...
}

Singleton évite que la classe ne soit instanciée en externe en limitant le constructeur à privé. Dans le cadre d'une même machine virtuelle, la seule instance de Singleton ne peut que passer. Accès à la méthode getInstance(). (En fait, il est possible d'instancier une classe avec un constructeur privé via le mécanisme de réflexion Java, ce qui invalidera fondamentalement toutes les implémentations Java singleton. Ce problème ne sera pas abordé ici. Faisons comme si le mécanisme de réflexion n'existait pas. . )

Mais l'implémentation ci-dessus ne prend pas en compte les problèmes de sécurité des threads. Ce qu'on appelle la sécurité des threads signifie que si plusieurs threads s'exécutent en même temps dans le processus où se trouve votre code, ces threads peuvent exécuter ce code en même temps. Si les résultats de chaque exécution sont les mêmes que ceux des exécutions monothread et que les valeurs des autres variables sont les mêmes que celles attendues, cela est thread-safe. En d'autres termes : l'interface fournie par une classe ou un programme est une opération atomique pour les threads ou le basculement entre plusieurs threads ne provoquera pas d'ambiguïté dans les résultats d'exécution de l'interface, ce qui signifie que nous n'avons pas besoin de prendre en compte les problèmes de synchronisation. De toute évidence, l'implémentation ci-dessus ne répond pas aux exigences de sécurité des threads et plusieurs instances Singleton sont susceptibles d'apparaître dans un environnement simultané.

public class TestStream {
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  } 
  //该类只能有一个实例
  private TestStream(){}  //私有无参构造方法
  //该类必须自行创建
  //有2种方式
  /*private static final TestStream ts=new TestStream();*/
  private static TestStream ts1=null;
  //这个类必须自动向整个系统提供这个实例对象
  public static TestStream getTest(){
    if(ts1==null){
      ts1=new TestStream();
    }
    return ts1;
  }
  public void getInfo(){
    System.out.println("output message "+name);
  }
}
/**
 * 
 */
public class TestMain {
  public static void main(String [] args){
    TestStream s=TestStream.getTest();
    s.setName("张孝祥");
    System.out.println(s.getName());
    TestStream s1=TestStream.getTest();
    s1.setName("张孝祥");
    System.out.println(s1.getName());
    s.getInfo();
    s1.getInfo();
    if(s==s1){
      System.out.println("创建的是同一个实例");
    }else if(s!=s1){
      System.out.println("创建的不是同一个实例");
    }else{
      System.out.println("application error");
    }
  }
}

Résultats en cours :

张孝祥
张孝祥
output message 张孝祥
output message 张孝祥
创建的是同一个实例

Conclusion : D'après les résultats , nous pouvons On sait que le modèle singleton fournit à une application orientée objet le seul point d'accès à un objet. Quelle que soit la fonction qu'elle implémente, l'application entière partagera un objet d'instance.

1. Cours singleton de style chinois affamé

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton1 {
  //私有的默认构造子
  private Singleton1() {}
  //已经自行实例化 
  private static final Singleton1 single = new Singleton1();
  //静态工厂方法 
  public static Singleton1 getInstance() {
    return single;
  }
}

2.

//懒汉式单例类.在第一次调用的时候实例化 
public class Singleton2 {
  //私有的默认构造子
  private Singleton2() {}
  //注意，这里没有final  
  private static Singleton2 single=null;
  //静态工厂方法 
  public synchronized static Singleton2 getInstance() {
     if (single == null) { 
       single = new Singleton2();
     } 
    return single;
  }
}

3. Classe singleton inscrite

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!