设计模式——单例模式（Singleton Pattern）

傷城~ 2022-10-22 15:56 149阅读 0赞

确保一个类在任何情况下都只有一个实例被返回，并提供一个全局访问点。

隐藏其所有构造方法，所有构造方法私有。属于创建型模式。

ServletContext、ServletConfig、ApplicationContext、DBPool

优点：

*  在内存中只有一个实例，减少内存开销。
 *  避免对资源的多重占用。
 *  设置了全局访问点，控制了访问。

缺点：没有接口，扩展困难，违背了开闭原则。

注意事项：

*  私有化构造器
 *  保证线程安全
 *  延迟加载
 *  防止序列化和反序列化破坏单例
 *  防御反射攻击破坏单例

# 1. 饿汉式单例 #

类加载时就已经被初始化。

优点：执行效率高，性能高，没有任何的锁。

缺点：在不使用的情况下会造成内存的浪费。

public class HungrySingleton {
        // 类加载的时候已经初始化，会占用内存空间，如果不使用，就会浪费内存
        private static HungrySingleton hungrySingleton = new HungrySingleton();
        private HungrySingleton() {}
        public HungrySingleton getInstance() {
            return hungrySingleton;
        }
    }

# 2. 懒汉式单例 #

第一次调用时才初始化。

## 2.1 简单懒汉式 ##

public class LazySingleton {
        // 加volatile避免指令重排序问题
        private volatile static LazySingleton lazySingleton;
        private LazySingleton() {}
        // synchronized加锁避免第一次访问时两个线程同时来创建实例
        // 但是方法锁会影响性能，后期每次获取实例都只能一次一个线程访问
        public synchronized LazySingleton getInstance() {
            if (null == lazySingleton) {
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    }

如果不加synchronized关键字，会有线程安全问题，多个线程同时访问有两种运行结果：

a. 同一个实例：正常顺序执行，但是后者结果覆盖了前者，从而打印。所以看着打印结果实例相同，实际上是两个实例。

b. 不同实例：同时进入条件，按顺序执行返回

## 2.2 DCL懒汉式 ##

对懒汉式单例进行优化：Double Check Lock

优点：调用的时候才初始化，如果不使用不占用内存空间，避免造成浪费。性能提升了，线程安全了。

缺点：可读性差了，两个if判断，代码不够优雅。

public class LazyDoubleCheckSingleton {
        // 加volatile避免指令重排序问题
        private volatile static LazyDoubleCheckSingleton lazySingleton;
        private LazyDoubleCheckSingleton() {}
        // synchronized加锁避免第一次访问时两个线程同时来创建实例
        public static LazyDoubleCheckSingleton getInstance() {
            if (null == lazySingleton) {//检查是否需要阻塞进入锁
                synchronized(LazyDoubleCheckSingleton.class) {
                    if (null == lazySingleton) {//检查是否已经创建实例
                        // 这里可能出现指令重排序问题，所以在声明地方加上volatile关键字
                        lazySingleton = new LazyDoubleCheckSingleton();
                    }
                }
            }
            return lazySingleton;
        }
    }

## 2.3 懒汉静态内部类 ##

通过内部类创建实例，然后调用内部类的静态变量获取实例。

优点：利用Java本身语法，通过内部类，性能高，避免内存浪费。

缺点：不优雅。

public class LazyStaticInnerClassSingleton {
        private LazyStaticInnerClassSingleton() {
            // 避免通过反射暴力获取对象实例
            if (null != LazyHelper.INSTANCE) {
                throw new RuntimeException("不允许通过反射获取实例");
            }
        }
        public LazyStaticInnerClassSingleton getInstance() {
            return LazyHelper.INSTANCE;
        }
        private static class LazyHelper {
            private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
        }
    }

# 3. 注册式单例 #

将每一个实例都缓存到统一的容器中，然后通过唯一的标识来获取实例。

## 3.1 枚举式单例 ##

枚举式单例在类加载时就已经将实例放在了一个Map类型的枚举常量字典enumConstantDirectory中

private volatile transient Map<String, T> enumConstantDirectory = null;

优点：简单优雅，线程安全，不会被反射破坏（JDK底层已经针对反射做了处理），

缺点：某些情况下可能造成内存浪费，声明的时候已经将实例放在了内存中。不适合在大量使用单例的情况下使用此方式。

public enum EnumSingleton {
        INSTANCE;
        public static final EnumSingleton getInstance(){
            return INSTANCE;
        }
    }

## 3.2 容器式单例 ##

针对以上枚举式单例的问题， Spring做出了改良，提出了容器式单例。

public class ContainerSingleton {
        private ContainerSingleton(){}
        private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();
        public static Object getInstance(String className) {
            Object instance = null;
            if (!ioc.containsKey(className)) {
                // 通过DCL双重检查锁解决线程安全问题
                synchronized (ioc) {
                    if (!ioc.containsKey(className)) {
                        try {
                            instance = Class.forName(className);
                            ioc.put(className, instance);
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            return instance = ioc.get(className);
        }
    }

## 3.3 序列化单例 ##

public class SerializableSingleton implements Serializable {
        private static final SerializableSingleton INSTANCE = new SerializableSingleton();
        private SerializableSingleton() {}
        public static SerializableSingleton getInstance() {
            return INSTANCE;
        }
        // 解决序列化、反序列化问题
        private Object readResolve() {return INSTANCE;}
    }

# 4. ThreadLocal单例 #

保证同一个线程内部全局唯一，且天生线程安全。不同线程中实例不同。

public class ThreadLocalSingleton {
        private static final ThreadLocal<ThreadLocalSingleton> threadLocalSingleton = new ThreadLocal<ThreadLocalSingleton>() {
            @Override
            protected ThreadLocalSingleton initialValue() {
                return new ThreadLocalSingleton();
            }
        };
        private ThreadLocalSingleton(){}
        public static ThreadLocalSingleton getInstance() {
            return threadLocalSingleton.get();
        }
    }