Wie schreibe ich ein Java-Singleton-Muster?

Singleton Pattern ist eines der einfachsten Designmuster in Java. Bei dieser Art von Entwurfsmuster handelt es sich um ein Erstellungsmuster, das eine optimale Möglichkeit zum Erstellen von Objekten bietet.

Dieses Muster beinhaltet eine einzelne Klasse, die für die Erstellung ihrer eigenen Objekte verantwortlich ist und gleichzeitig sicherstellt, dass nur ein einziges Objekt erstellt wird. Diese Klasse bietet eine Möglichkeit, direkt auf ihre eindeutigen Objekte zuzugreifen, ohne dass ein Objekt der Klasse instanziiert werden muss.

Hinweis:

1. Eine Singleton-Klasse kann nur eine Instanz haben. 2. Eine Singleton-Klasse muss ihre eigene eindeutige Instanz erstellen. 3. Die Singleton-Klasse muss diese Instanz allen anderen Objekten bereitstellen.

5 Möglichkeiten, den Java-Singleton-Modus zu schreiben:

1. Vollständiger Modus (Lazy-Modus)

// 饱汉
// UnThreadSafe
public class Singleton1 {
  private static Singleton1 singleton = null;
  private Singleton1() {
  }
  public static Singleton1 getInstance() {
    if (singleton == null) {
      singleton = new Singleton1();
    }
    return singleton;
  }
}

Vorteile : Lazy Loading startet schnell, beansprucht wenig Ressourcen, wird bei Verwendung instanziiert und ist sperrenfrei.

Nachteile: Nicht threadsicher.

2. Lazy-Modus (Lazy-Modus) - Thread-Sicherheit

public class Singleton {
    /**
     * 定义一个变量来存储创建好的类实例
     */
    private static Singleton uniqueInstance = null;
    /**
     * 私有化构造方法，好在内部控制创建实例的数目
     */
    private Singleton(){
    }
    /**
     * 定义一个方法来为客户端提供类实例
     * @return 一个Singleton的实例
     */
    public static synchronized Singleton getInstance(){
        //判断存储实例的变量是否有值
        if(uniqueInstance == null){
            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
            uniqueInstance = new Singleton();
        }
        //如果有值，那就直接使用
        return uniqueInstance;
    }
    /**
     * 示意方法，单例可以有自己的操作
     */

    public void singletonOperation(){
//功能处理
    }
    /**
     * 示意属性，单例可以有自己的属性
     */
    private String singletonData;
    /**
     * 示意方法，让外部通过这些方法来访问属性的值
     * @return 属性的值
     */
    public String getSingletonData(){
        return singletonData;
    }
}

Vorteile: Wie oben, aber gesperrt.

Nachteile: synchronisiert ist eine exklusive Sperre und weist eine schlechte Parallelitätsleistung auf. Auch nach erfolgreicher Erstellung ist das Abrufen der Instanz immer noch ein serialisierter Vorgang.

3. Lazy-Modus (Lazy-Modus) - Double Check Lock DCL (Double Check Lock)

public class Singleton {
    /**
     * 对保存实例的变量添加volatile的修饰
     */
    private volatile static Singleton instance = null;
    private Singleton(){
    }

    public static Singleton getInstance(){
//先检查实例是否存在，如果不存在才进入下面的同步块
       if(instance == null){
//同步块，线程安全的创建实例
            synchronized(Singleton.class){
//再次检查实例是否存在，如果不存在才真的创建实例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Vorteile: Lazy Loading, Thread-Sicherheit.

Hinweis: Die Instanz muss mit dem Schlüsselwort volatile geändert werden, um eine vollständige Initialisierung sicherzustellen.

4. Hungry Mode

public class Singleton {
//4：定义一个静态变量来存储创建好的类实例
//直接在这里创建类实例，只会创建一次
    private static Singleton instance = new Singleton();
//1：私有化构造方法，好在内部控制创建实例的数目
    private Singleton(){
    }
//2：定义一个方法来为客户端提供类实例
//3：这个方法需要定义成类方法，也就是要加static
//这个方法里面就不需要控制代码了
   public static Singleton getInstance(){
//5：直接使用已经创建好的实例
       return instance;
    }
}

Vorteile: Der Hungry Mode ist von Natur aus threadsicher und es gibt keine Verzögerung bei der Verwendung.

Nachteile: Eine Instanz wird beim Start erstellt, verlangsamt den Start und kann zu einer Verschwendung von Ressourcen führen.

5. Holder-Modus

public class Singleton {
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static Singleton instance = new Singleton();
    }
    /**
     * 私有化构造方法
     */
    private Singleton(){
    }
    public static  Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

Vorteile: Eine perfekte Kombination aus Lazy Loading und Thread-Sicherheit (keine Sperren). (Empfohlen)

Verwandte Lernempfehlungen: Java-Grundlagen-Tutorial

Das obige ist der detaillierte Inhalt vonWie schreibe ich ein Java-Singleton-Muster?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!