java单例模式

单例模式（Singleton），保证一个类仅有一个实例，并提供一个访问它的全局访问点。

使用场景：在一个系统中，要求一个类有且仅有一个对象，如果出现多个对象就会出现“不良反映”，可以使用单例模式。例如：在计算机系统中，线程池、缓存、日志对象、web计数器等 常被设计成单例。这些应用都或多或少具有资源管理器的功能。

优点：

（1）单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化， 单例模式的优势就非常明显。

（2）单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象， 然后用永久驻留内存的方式来解决（在Java EE中采用单例模式时需要注意JVM垃圾回收机制）。

（3）单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

（4）单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

缺点：

（1）单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能增加接口呢？因为接口对单例模式是没有任何意义的，它要求“自行实例化”，并且提供单一实例、接口或抽象类是不可能被实例化的。当然，在特殊情况下，单例模式可以实现接口、被继承等，需要在系统开发中根据环境判断。

（2）单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象。

（3）单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。

（摘自《设计模式之禅》）

单例模式一般分为懒汉式和饿汉式两种：

区别：

饿汉式：在类加时就创建对象，线程是安全的，但是没有延迟加载，如果没有使用就是浪费内存。

懒汉式：在类加载的时候不创建，而是在实际用到时创建，线程不安全（故需加上synchronized），但具有延迟加载的特性。

实现代码如下：

饿汉式：

public class SingletonDemo1 {
    
    //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
    private static SingletonDemo1 instance = new SingletonDemo1();  
    
    private SingletonDemo1(){
    }
    
    //方法没有同步，调用效率高！
    public static SingletonDemo1  getInstance(){
        return instance;
    } 
}

懒汉式：

public class SingletonDemo2 {
    
    //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
    private static SingletonDemo2 instance;  
    
    private SingletonDemo2(){ //私有化构造器
    }
    
    //方法同步，调用效率低！
    public static  synchronized SingletonDemo2  getInstance(){
        if(instance==null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
    
}

怎么能同时具有以上两种模式的共同特点呢？

常用的方式有两种：（1）双重检查锁实现单例模式 （2）静态内部类实现单例模式

双重检查锁实现单例模式由于JVM编译器的原因，有的时候会出现问题（不建议使用），代码如下，仅做参考：

public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 

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

  private SingletonDemo3() { 

  }    
}

静态内部类实现单例模式（建议使用这种方式），代码如下：

/**
 * 这种方式：线程安全，调用效率高，并且实现了延时加载！
 */
public class SingletonDemo4 {
    
    private static class SingletonClassInstance {
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }
    
    private SingletonDemo4(){
    }
    
    //方法没有同步，调用效率高！
    public static SingletonDemo4  getInstance(){
        return SingletonClassInstance.instance;
    }
    
}

还有一种是使用枚举的方式实现单例模式（我没有实际用过），这里代码给大家参考：

/**
 * 枚举式实现单例模式(没有延时加载)
 */
public enum SingletonDemo5 {
    
    //这个枚举元素，本身就是单例对象！
    INSTANCE;
    
    //添加自己需要的操作！
    public void singletonOperation(){
    }
        
}

从严格的意义上来说把构造器私有后，并不是就不能再创建它的实例了，还可以通过其他的方式进行实例化。这里就和java中创建对象的几种方式相关。

在java中有四种创建对象的方式：

（1）通过构造器直接new

（2）可以通过clone方法创建

（3）通过反射的方式进行创建

（4）通过反序列化的方式创建

这样，虽然私有了构造器，但是还是可以通过反射和反序列化的方式创建对象。

为了防止通过反射的方式直接创建对象破坏单例模式的结构，可以在构造器中添加判断抛出异常，如下：

private SingletonDemo6(){ //私有化构造器
    if(instance!=null){
        throw new RuntimeException();
    }
}

为了防止通过反序列化的方式创建对象破坏单例模式的结构，可以在复写readResolve个方法，这样在反序列化的时候直接调用这个方法，如下：

//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
private Object readResolve() throws ObjectStreamException {
    return instance;
}

这样，基本就保证了单例模式的可靠行了。

附上完整的防止反射和反序列化创建对象的代码：

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 懒汉式单例模式(如何防止反射和反序列化漏洞)
 */
public class SingletonDemo6 implements Serializable {
    //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
    private static SingletonDemo6 instance;  
    
    private SingletonDemo6(){ //私有化构造器
        if(instance!=null){
            throw new RuntimeException();
        }
    }
    
    //方法同步，调用效率低！
    public static  synchronized SingletonDemo6  getInstance(){
        if(instance==null){
            instance = new SingletonDemo6();
        }
        return instance;
    }
    
    //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }
    
}

扩展，如果一个类可以产生多个对象，对象的数量不受限制，则是非常容易实现的，直接使用new关键字就可以了，如果只需要一个对象，使用单例模式就可以了，但是如果要求一个类只能产生两三个对象呢？该怎么实现？

这里可以对单例模式进行扩展，如下：

public class SingletonDemo7 {
    
    //定义最多能产生的实例数量
    private static int maxNumOfSingletonDemo = 2;
    //定义一个列表，容纳所有的实例
    private static ArrayList<SingletonDemo7> SingletonDemoList=new ArrayList<SingletonDemo7>();
    //当前序列号
    private static int countNumOfSingletonDemo =0;
    //产生所有的对象
    static{
        for(int i=0;i<maxNumOfSingletonDemo;i++){
            SingletonDemoList.add(new SingletonDemo7());
        }
    }
    
    private SingletonDemo7(){
    }
    
    //随机获得一个对象
    public static SingletonDemo7 getInstance(){
    Random random = new Random();
    //随机
    countNumOfSingletonDemo = random.nextInt(maxNumOfSingletonDemo);
    return SingletonDemoList.get(countNumOfSingletonDemo);
    }
    
}