Eine kurze Diskussion über mehrere gängige Entwurfsmuster in Java: Singleton-Muster

1. Singleton-Muster

Es ist eines der am häufigsten verwendeten Entwurfsmuster in Java. Seine Kernstruktur enthält nur eine spezielle Klasse namens Singleton. Das Singleton-Muster kann sicherstellen, dass es nur eine Instanz der Klasse im System gibt, die dieses Muster anwendet.

2. Musteranforderungen

1. Ihre eigene Konstruktionsmethode muss privat sein

2 eine öffentliche statische Methode für andere Objekte, um die Instanz zu erhalten

3. Mehrere Implementierungsmethoden

Hungriger chinesischer Stil

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

Diese Implementierungsmethode wird verwendet, wenn die Klasse geladen wird. Instanziierung ist erfolgt ohne Lazy Loading und ist Thread-sicher.

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;
}
}

Diese Implementierung ist die grundlegendste Implementierung. Das größte Problem besteht darin, dass gleichzeitige Zugriffsmethoden streng genommen nicht unterstützt werden Es ist kein Singleton-Modell.

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;
}
}

Diese Methode zum Hinzufügen synchronisierter Sperren zu Methoden kann das Problem des gleichzeitigen Zugriffs durch Threads lösen und Singletons implementieren. Das Hinzufügen von Sperren beeinträchtigt jedoch die Effizienz und wird daher häufig nicht auf diese Weise verwendet.

Sperre doppelt prüfen

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;
}
}

Diese Methode verwendet einen Doppelsperrmechanismus, der sich an den gleichzeitigen Multithread-Zugriff anpassen und eine hohe Leistung aufrechterhalten kann.

Statische innere Klassenimplementierung

/**
* 静态内部类方式实现单例模式
*
* 当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;
}
}

Diese Methode kann nicht nur einen sicheren Multithread-Zugriff erreichen, sondern auch den internen Klassenlademechanismus verwenden, um verzögertes Laden zu erreichen.

Das obige ist der detaillierte Inhalt vonEine kurze Diskussion über mehrere gängige Entwurfsmuster in Java: Singleton-Muster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!