单例模式

  • 单例模式：确保一个类在任何情况下绝对只有一个实例，并且提供全局的访问点

饿汉式单例

  • 加载方式：再类加载的时候就立即初始化，并且创建单例对象。
  • 线程安全：线程绝对安全。
  • 缺点：类加载的时候就初始化，浪费资源

  • 创建方式:

    • 私有化构造方法。
    • 创建静态常量，并且在类初始化赋值成类对象。

    • 提供全局访问点，返回静态常量（类对象） ```java public class HungrySingleton { private static final HungrySingleton INSTANCE = new HungrySingleton();

      private HungrySingleton() { }

      public static HungrySingleton getInstance() { return INSTANCE; } }

  2. <a name="o56Dh"></a>
  3. ## 懒汉式单例
  5. <a name="lYbiB"></a>
  6. ### _内部类加载_
  8. - **加载方式**：延迟加载
  9. - **线程安全**：线程安全。
  10. - **缺点**：
  11. ```java
  12. public class LazyInnerClassSingleton implements Serializable {
  14.     private LazyInnerClassSingleton() {
  15.         // 防止被反射破坏
  16.         if (InnerSingleton.INSTANCE != null) {
  17.             throw new RuntimeException("非法访问");
  18.         }
  19.     }
  21.     public static LazyInnerClassSingleton getInstance() {
  22.         return InnerSingleton.INSTANCE;
  23.     }
  25.     // 默认不加载，只有调用的时候才会加载
  27.     private static class InnerSingleton {
  28.         private static LazyInnerClassSingleton INSTANCE = new LazyInnerClassSingleton();
  29.     }
  31.     // 防止序列化和返序列化
  33.     private Object readResolve() {
  34.         return InnerSingleton.INSTANCE;
  35.     }
  36. }

双锁检验

  • 加载方式：延迟加载
  • 线程安全：线程安全。

  • 缺点： ```java public class LazySingleton implements Serializable { private static volatile LazySingleton INSTANCE = null;

    private LazySingleton() {

    1.   // 防止被反射破坏
    2.   if (INSTANCE != null) {
    3.       throw new RuntimeException("非法访问");
    4.   }

    } // 增加双锁检测 线程安全，延时加载

    public static LazySingleton getInstance() {

    1.   if (INSTANCE == null) {
    2.       synchronized (LazySingleton.class) {
    3.           if (INSTANCE == null) {
    4.               INSTANCE = new LazySingleton();
    5.           }
    6.       }
    7.   }
    8.   return INSTANCE;

    } }

  2. <a name="Wdhd0"></a>
  3. ## 注册式单例
  5. <a name="gW72g"></a>
  6. ### _注册式单例- 容器单例_
  8. - _容器式单例适用于创建实例非常多的情况，便于管理。但是，是非线程安全的_
  9. ```java
  10. public class ContainerSingleton {
  11.     private ContainerSingleton() {
  12.     }
  14.     private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();
  16.     public static Object getBean(String className) {
  17.         synchronized (ioc) {
  18.             if (!ioc.containsKey(className)) {
  19.                 Object obj = null;
  20.                 try {
  21.                     obj = Class.forName(className);
  22.                     ioc.put(className, obj);
  23.                 } catch (ClassNotFoundException e) {
  24.                     e.printStackTrace();
  25.                 }
  26.                 return obj;
  27.             } else {
  28.                 return ioc.get(className);
  29.             }
  30.         }
  31.     }
  32. }

注册式单例- 枚举单例

  • 优点：枚举类不能通过反射创建，现成安全

  • 缺点：属于懒加载，直接加载在内存中 ```java public enum EnumSingleton { // INSTANCE; private Object data;

    public Object getData() {

    1.   return data;

    }

    public void setData(Object data) {

    1.   this.data = data;

    }

    public static EnumSingleton getInstance() {

    1.   return INSTANCE;

    }

} ```