设计模式之单例模式

一、 什么是单例模式

一个类有且仅由一个实例，单例类需要负责实例化和提供全局访问

二、 为什么要使用单例模式

如果产生过多的对象浪费系统资源，为避免频繁的创建和销毁对象对资源的浪费，如线程池，网络请求，对数据库访问；某种类型应该只有一个，如果由多个实例存在，可能会导致程序使用异常，资源使用过量，导致结果不一致等问题

三、 单例模式的优缺点

优点：减少系统内存使用，避免对资源的同时操作导致的异常

缺点：容易引起内存泄漏，与一个类单一职责原则冲突，还要关心自己是否是单例

四、 各种实现方法

本质：构造函数私有化，提供获取唯一实例的静态方法，保证该方法是线程安全的，考虑使单例失效的因素：由反序列化，克隆，多线程，反射等，

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

这种写法能保证线程安全，但是对整个方法加锁导致效率低，每一次执行getInstance都会进行同步，实际上在实例被创建以后，再执行getInstance就没有必要再同步了， 可以将其修改为同步代码块

2、public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {
    }
    public static  Singleton getInstance() {
        if (instance == null) {
            // 第一次判空，避免不必要的同步，即已经实例化后，再次执行getInstance时可以避免同步
            synchronized (Singleton.class){
                if (instance == null)
                    // 第二次判空，保证只创建一个实例
                    instance = new Singleton();
            }
        }
        return instance;
    }
}

 

注意此时要使用两次判空，即双重检查，否则可能产生多个实例，其中volatile关键字的使用是因为：看了一些文章，和java指令重排有关，instance = new Singleton()，不是原子操作，会被分成三个指令：1.申请一块内存，2.调用构造函数初始化内存空间，3. 引用指向这块内存，指令重拍后可能执行顺序时132，执行到13时，instance != null，如果这时有一个线程调用getInstance，就会返回该引用，但是这块内存并未被初始化，访问会出现异常，因此使用volatile关键字禁止java指令重排

3、静态内部类方法

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

方法1，2是延迟加载，方法3也是延迟加载，只有在第一次调用getInstance时才会加载，对于一些使用频率较低的单例类推荐使用延迟加载，不使用不加载，它们共同的特点是：延迟加载，线程安全，效率较高（同步）。

4、上述方法都是延迟加载，即懒汉式，下面介绍饿汉式

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

 

5、public class Singleton {
   private Singleton() {
   }
   private static Singleton instance = null;
  
   static {
       instance = new Singleton();
   }

   public static Singleton getInstance(){
       return instance;
   }
}

上述两种方法都是饿汉式，类装载时就会实例化，天生是线程安全的

6、饿汉式和懒汉式的选择

主要是空间和时间的选择上，饿汉式因为类装载时就已实例化，因此第一次调用的时候更快，程序运行期间会一直占用内存，不管是否使用，懒汉式是延迟加载，优点是内存使用率高，但是第一次调用初始化会较慢

工作学习中遇到的哪些单利模式

使用的单例类ChannelManager，该类管理频道数据，获取，查询等，因为应用中多个地方会访问和修改数据，为了保证数据的一致性，使用单例模式，而且单例模式在整个应用运行期间只存在一个实例，可以有效节约内存空间

 

破坏单例类的因素之反序列化

单例类如果实现了Serializable，可以被保存和传输，单例类被反序列化后得到的将是一个新的实例，要避免产生新的实例，需要实现readResolve方法，在反序列化时，从输入流中读取对象的readObject方法被调用后，在readResolve中用原来的instance替换掉流中读取到的新创建的instance，这样就避免了序列化方式破坏了单例

public class Singleton implements Serializable {
    private static final Singleton instance= new Singleton();
    private Singleton() {}
    public static Singleton getInstance(){
        return instance;
    }
    private Object readResolve() {
        return instance;
    }
}

破坏单例类的因素之反射

反射可以调用到类的私有构造函数，用来创建对象，为避免这种情况，可以在构造函数的时候加一个判断，如果存在，说明是第二次创建

public class Singleton implements Serializable {
    private static final Singleton instance= new Singleton();
    private Singleton() {
        if (instance != null)
            throw new RuntimeException("cannot contruct singleton more than once");
    }
    public static Singleton getInstance(){
        return instance;
    }
}

 

破坏单例类的因素之克隆

如果单例类实现了clone接口，尽管其构造函数是私有的，仍可以通过克隆创建一个新对象导致单例失效，所以单例类不要实现克隆接口，如果单例类的父类实现了接口，单例类可以重写，在clone中抛出异常

public class Singleton {
    private static final Singleton instance= new Singleton();
    private Singleton() {
    }
    public static Singleton getInstance(){
        return instance;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException{
        throw new CloneNotSupportedException();
    }
}

 

登记式单例

随着代码越来越负载，可能用到多个处理不同业务的单例，这时可以使用map容器同意管理单例

public class SingletonManager {
    private HashMap<String, Object>map = new HashMap<>();
    private SingletonManager() {}
    public void registerService(Stringkey, Object instance) {
        if (!map.containsKey(key))
            map.put(key, instance);
    }
    public Object getService(String key){
        return map.get(key);
    }
}