单例模式

定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点，其他的方法都是私有的。

在实际开发中，单例模式经常被用于管理资源、共享数据等场景

单例模式有多种写法各有利弊，现在我们来看看各种模式写法。

1. 饿汉模式

public class Singleton {  
     private static Singleton instance = new Singleton();  
     private Singleton (){
     }
     public static Singleton getInstance() {  
     return instance;  
     }  
 }

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

2. 懒汉模式（线程不安全）

public class Singleton {  
      private static Singleton instance;  
      private Singleton (){
      }   
      public static Singleton getInstance() {  
      if (instance == null) {  
          instance = new Singleton();  
      }  
      return instance;  
      }  
 }  

懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作。

3. 懒汉模式（线程安全）

public class Singleton {  
      private static Singleton instance;  
      private Singleton (){
      }
      public static synchronized Singleton getInstance() {  
      if (instance == null) {  
          instance = new Singleton();  
      }  
      return instance;  
      }  
 } 

这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。

4. 双重检查模式 （DCL）

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
        if (instance != null) {
            throw new RuntimeException("不允许非法访问");
        }

    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，防止指令重排序了。
在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。

5. 静态内部类单例模式

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return SingletonHolder.sInstance;  
    }  
    private static class SingletonHolder {  
        private static final Singleton sInstance = new Singleton();  
    }  
} 

第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

6. 枚举单例、

public enum Singleton {  
     INSTANCE;  
     public void doSomeThing() {  
     }  
 } 

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例，上述讲的几种单例模式实现中，有一种情况下他们会重新创建对象，那就是反序列化，将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了readResolve方法，这个方法可以让开发人员控制对象的反序列化。在上述的几个方法示例中如果要杜绝单例对象被反序列化是重新生成对象，就必须加入如下方法：

private Object readResolve() throws ObjectStreamException{
return singleton;
}

 

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

7. 使用容器实现单例模式

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)){
            try {
                instance = Class.forName(className).newInstance();
                ioc.put(className, instance);
            }catch (Exception e){
                e.printStackTrace();
            }
            return instance;
        }else{
            return ioc.get(className);
        }
    }

}

用ContainerSingleton 将多种的单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

总结

到这里七中写法都介绍完了，至于选择用哪种形式的单例模式，取决于你的项目本身，是否是有复杂的并发环境，还是需要控制单例对象的资源消耗。

饿汗式单例。 没必要讲，在类初始化创建 ，线程安全。

懒汉式单例。在我们使用的时候创建。容易出现问题

　　1. 线程不安全。

           在是否创建对象判断的时候加锁 线程安全，速度慢。

　　　双检查锁  线程安全 速度稍微快点。

　　　静态内部类 线程安全 速度快。

   public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return singleton;
    }

 

　　2. 指令重排序 在变量上加 volatile 关键字。

private volatile static Singleton instance;

 

　　3. 防止反射暴力调用 构造方法，创建实例对象。  在构造方法中加入校验。 如果 创建的单例对象不为null ,就抛异常。

   private Singleton() {
        if (instance != null) {
            throw new RuntimeException("不允许非法访问");
        }

    }

　　4. 防止返序列化造成对象的不唯一。。

　　　　加上  可以让开发人员控制对象的反序列化。让反序列化的对象。都是同一个对象

private Object readResolve() throws ObjectStreamException{
return singleton;
}

 

应用场景

数据库连接池

在数据库连接池中，需要保证每个线程都使用同一个数据库连接对象，以避免频繁地创建和销毁连接对象。使用单例模式可以方便地管理数据库连接对象，并保证线程安全。

日志记录器

在日志记录器中，需要保证只有一个实例对象可以记录日志信息。使用单例模式可以方便地对日志信息进行管理和共享。

配置文件读取器

在配置文件读取器中，需要保证只有一个实例对象可以读取配置文件。使用单例模式可以方便地管理和共享配置文件对象。

图形界面中的对话框

在图形界面中的对话框中，需要保证每个对话框只有一个实例对象，以避免创建过多的对话框对象，从而导致内存浪费。使用单例模式可以方便地管理对话框对象，并保证线程安全。

线程池

在线程池中，需要保证每个线程都使用同一个线程池对象，以避免频繁地创建和销毁线程池对象。使用单例模式可以方便地管理线程池对象，并保证线程安全。

缓存

在缓存中，需要保证只有一个实例对象可以对缓存进行管理和共享。使用单例模式可以方便地管理缓存对象，并保证线程安全。

总之，单例模式在很多需要限制实例个数的场景下都非常有用。

　　实际项目中使用 全局数据初始化 ExpiryHashMap 。

　　　　比如做的是基础数据的模块。需要很多的基础数据的配置项目。而且这种配置项可能会改。 这时候。我们可以做用定时任务吧这种配置项查出来。放到缓冲（有过期时间），给项目使用。 

　　我们不想用redis 。所有自己写了个会过期的 ExpiryHashMap 全局唯一。这里就用到了单例。