设计模式之单例模式

最新推荐文章于 2022-08-29 00:23:19 发布

吃了么没吃回家吃点儿

最新推荐文章于 2022-08-29 00:23:19 发布

阅读量112

点赞数

分类专栏：代码设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/chileme/article/details/82938585

版权

代码设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

关键点:
- 构造函数不对外开放，一般为Private
- 通过一个静态方法或者枚举返回单例类对象
- 确保单例类的对象有且只有一个，尤其在多线程的状态下
- 确保单例类的对象在反序列化时不会重新构建对象

一、实现

1、饿汉式

    public class Singleton {
        private static final Singleton mSingleton = new Singleton();
        
        private Singleton(){
            //单例的构造方法
        }
        
        private static Singleton getInstance() {
            return mSingleton;
        }
    }

优点：在声明静态对象时就已经初始化，天生就是线程安全的
缺点：在声明Singleton对象的时候就初始化了对象

2、懒汉式

    public class Singleton {
        private static Singleton instance;
        
        private Singleton() {
            //单例的构造方法   
        }
        
        private static synchronized Singleton getInstance(){
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

优点：只有在使用的时候才会被实例化
缺点：第一次加载时需要及时进行实例化，每次调用getInstance都进行同步，造成不必要的同步开销
- 如果不加synchronized则会出现线程不安全的问题

3、DoubleCheckLock（双重检查）

    public class Singleton {
        private volatile static Singleton mInstance = null;
        
        private Singleton() {
            //单例的构造方法
        }
        
        public static Singleton getInstance() {
            if (mInstance == null) {
                synchronized (Singleton.class) {
                    if (mInstance == null) {
                        mInstance = new Singleton();
                    }
                }
            }
            
            return mInstance;
        }
        
    }

特点：双重的意思是对instance进行了两次判空
- 第一层判断主要是为了避免不必要的同步
- 第二层判断则是为了在null的情况下创建实例
mInstance = new Singleton()；语句会被编译成多条汇编指令
- （1）给Singleton的实例分配内存
- （2）调用Singleton()的构造函数，初始化成员字段
- （3）将mInstance对象指向分配的内存空间（此时mInstance就不是null了）
由于Java编译器允许处理器乱序执行，所以执行顺序可能是1-2-3，也可能是1-3-2，可能存在instance未被初始化的问题。
- 通过volatile关键字确保mInstance对象的创建顺序是1-2-3（jdk 1.4之后）
优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化
缺点：第一次加载时反应稍慢

4、静态内部类单例模式（推荐）

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

优点：
- 第一次加载Singleton类时并不会初始化mInstance，只有在第一次调用Sinleton的getInstance方法时才会导致mInstance被初始化
- 确保线程安全，保证单利对象的唯一性
- 同时延迟了单例的实例化

二、实现中出现的问题

1、避免序列化对单例造成的破坏

原因：序列化会通过反射调用无参数的构造方法创建一个新的对象

实现方法：在单例中定义 private Object readResolve()

public class Singleton implements Serializable{
    private volatile static Singleton singleton;
    
    private Singleton (){}
    
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }
}

原理：
- 对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的
- ObjectInputStream的readObject的调用栈：
  readObject--->readObject0--->readOrdinaryObject--->checkResolve
  - ObjectInputputStream 的 readOrdinaryObject 方法执行情况
```
private Object readOrdinaryObject(boolean unshared) throws IOException
{
    //此处省略部分代码

    Object obj;
    try {
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        throw (IOException) 
            new InvalidClassException(desc.forClass().getName(),"unable to create instance").initCause(ex);
    }

    //此处省略部分代码

    if (obj != null && handles.lookupException(passHandle) == null &&desc.hasReadResolveMethod()) {
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        if (rep != obj) {
            handles.setObject(passHandle, obj = rep);
        }
    }

    return obj;
}
```
    - isInstantiable：如果一个serializable/externalizable的类可以在运行时被实例化，那么该方法就返回true。
    - desc.newInstance()：该方法通过反射的方式调用无参构造方法新建一个对象。
      - 这就是序列化破坏单例的原因
    - hasReadResolveMethod：如果实现了serializable 或者 externalizable接口的类中包含readResolve则返回true
    - invokeReadResolve()：通过反射的方式调用要被反序列化的类的readResolve方法。
      - 这就是防止序列化破坏单例的方法

2、饿汉式单例可能被反射破坏

public class Test {
    public static void main(String[] args) throws Exception{
        Singleton s1 = Singleton.getInstance();
 
        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton s2 = constructor.newInstance();
 
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
 
    }
}

输出结果：
671631440
935563443    -----> 生成了不同的对象

原因：通过反射获得单例类的构造函数，由于该构造函数是private的，通过setAccessible(true)指示反射的对象在使用时会取消 Java 语言访问检查,使得私有的构造函数能够被访问，这样使得单例模式失效。

改进：防止构造函数被成功调用两次。

需要在构造函数中对实例化次数进行统计，大于一次就抛出异常。

public class Singleton {
    private static int count = 0;

    private static Singleton instance = null;

    private Singleton(){
        synchronized (Singleton.class) {
            if(count > 0){
                throw new RuntimeException("创建了两个实例");
            }
            count++;
        }
    }

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

    public static void main(String[] args) throws Exception {

        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton s1 = constructor.newInstance();
        Singleton s2 = constructor.newInstance();
    }

}

输出结果：
Exception in thread "main" java.lang.reflect.InvocationTargetException
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
at java.lang.reflect.Constructor.newInstance(Unknown Source)
at com.yzz.reflect.Singleton.main(Singleton.java:33)
Caused by: java.lang.RuntimeException: 创建了两个实例
at com.yzz.reflect.Singleton.<init>(Singleton.java:14)
... 5 more