说说什么是单例模式？

# 单例模式 ## 使用场景 在整个系统中，只能存在一个对象实例，也就是说只能new一次 ## 分类 ### 饿汉式 #### 定义 在系统启动后，就会实例化一个对象(不管用不用得到，我先买了再说) - 缺点：造成内存浪费（如果从来没有使用过） - 优点：不会造成线程安全的问题 #### 实现方式 ##### 静态常量 ``` class EHPatternInstance1{ private final static EHPatternInstance1 INSTANCE = new EHPatternInstance1(); private EHPatternInstance1(){ } public static EHPatternInstance1 getInstance(){ return INSTANCE; } } ``` ##### 静态代码块 ``` class EHPatternInstance2{ private static EHPatternInstance2 INSTANCE; static { INSTANCE = new EHPatternInstance2(); } private EHPatternInstance2(){ } public static EHPatternInstance2 getInstance(){ return INSTANCE; } } ``` ### 懒汉模式 #### 定义 在需要用到的时候才进行实例化(作业等老师快要检查了才做) - 优点：节省内存，如果永远不会用到，则将不会被创建 - 缺点：需要考虑线程安全问题 #### 实现方式 ##### 有线程安全问题 ``` class LHPatternThreadUnSafe{ private static LHPatternThreadUnSafe INSTANCE; private LHPatternThreadUnSafe(){ } public static LHPatternThreadUnSafe getInstance(){ if (INSTANCE == null) { INSTANCE = new LHPatternThreadUnSafe(); return INSTANCE; } return INSTANCE; } } ``` ##### 同步方法 ``` /** * 同步方法 */ class LHPatternThreadSafe{ private static LHPatternThreadSafe INSTANCE; private LHPatternThreadSafe(){ } public static synchronized LHPatternThreadSafe getInstance(){ if (INSTANCE == null) { INSTANCE = new LHPatternThreadSafe(); return INSTANCE; } return INSTANCE; } } ``` - 同步代码块 ``` /** * 同步代码块 */ class LHPatternThreadSafeCodeBlock{ private static LHPatternThreadSafeCodeBlock INSTANCE; private LHPatternThreadSafeCodeBlock(){ } public static LHPatternThreadSafeCodeBlock getInstance(){ if (INSTANCE == null) { synchronized (LHPatternThreadSafeCodeBlock.class){ INSTANCE = new LHPatternThreadSafeCodeBlock(); } return INSTANCE; } return INSTANCE; } } ``` ##### 双重检查 ``` /** * 同步代码块 双重检查 */ class LHPatternThreadSafeDoubleCheck{ private static LHPatternThreadSafeDoubleCheck INSTANCE; private LHPatternThreadSafeDoubleCheck(){ } public static LHPatternThreadSafeDoubleCheck getInstance(){ if (INSTANCE == null) { synchronized (LHPatternThreadSafeDoubleCheck.class){ if (INSTANCE == null) { INSTANCE = new LHPatternThreadSafeDoubleCheck(); } } return INSTANCE; } return INSTANCE; } } ``` ##### volatile ``` /** * 同步代码块 volatile */ class LHPatternThreadSafeVolatile{ private volatile static LHPatternThreadSafeVolatile INSTANCE; private LHPatternThreadSafeVolatile(){ } public static LHPatternThreadSafeVolatile getInstance(){ if (INSTANCE == null) { synchronized (LHPatternThreadSafeVolatile.class){ if (INSTANCE == null){ INSTANCE = new LHPatternThreadSafeVolatile(); } } return INSTANCE; } return INSTANCE; } } ``` ##### 静态内部类 ``` /** * 静态内部类 */ class LHPatternInnerClass{ static class LHPatternInnerClassInstance{ private static final LHPatternInnerClass INSTANCE = new LHPatternInnerClass(); } public static LHPatternInnerClass getInstance(){ return LHPatternInnerClassInstance.INSTANCE; } } ```

单例模式是一种创建型设计模式，旨在确保一个类在应用程序中只有一个实例存在，并提供一个全局访问点来访问该实例。这种模式常用于需要唯一控制资源的场景，比如数据库连接、线程池等。 ### 单例模式的优点 - **节省资源**：避免频繁创建和销毁对象，减少系统资源的浪费。 - **全局访问点**：提供一个全局的访问点，方便获取唯一实例。 - **控制实例数**：确保类在整个系统中只有一个实例，避免出现多实例问题。 ### 单例模式的几种实现方式 #### 1. 饿汉式单例（线程安全） 饿汉式单例在类加载时就创建实例，因此线程安全。 ```java public class HungrySingleton { private static final HungrySingleton INSTANCE = new HungrySingleton(); private HungrySingleton() {} public static HungrySingleton getInstance() { return INSTANCE; } } ``` #### 2. 懒汉式单例（非线程安全） 懒汉式单例在需要的时候才创建实例，但在多线程环境下可能会创建多个实例。 ```java public class LazySingleton { private static LazySingleton instance; private LazySingleton() {} public static LazySingleton getInstance() { if (instance == null) { instance = new LazySingleton(); } return instance; } } ``` #### 3. 双重检查锁定（线程安全） 双重检查锁定在需要的时候创建实例，同时通过双重检查和同步块确保线程安全。 ```java public class DoubleCheckedLockingSingleton { private static volatile DoubleCheckedLockingSingleton instance; private DoubleCheckedLockingSingleton() {} public static DoubleCheckedLockingSingleton getInstance() { if (instance == null) { synchronized (DoubleCheckedLockingSingleton.class) { if (instance == null) { instance = new DoubleCheckedLockingSingleton(); } } } return instance; } } ``` #### 4. 静态内部类（线程安全） 利用静态内部类的特性，实现延迟加载和线程安全。 ```java public class StaticInnerClassSingleton { private StaticInnerClassSingleton() {} private static class SingletonHolder { private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton(); } public static StaticInnerClassSingleton getInstance() { return SingletonHolder.INSTANCE; } } ``` ### 总结 单例模式是一种确保一个类只有一个实例的设计模式，适用于需要全局唯一实例的场景。不同的实现方式有不同的优缺点，选择合适的实现方式取决于具体的需求和环境。例如，在单线程环境下可以选择懒汉式，而在多线程环境下则应选择双重检查锁定或静态内部类方式。