设计模式之一：单例模式

一、概念

单例模式是一种创建型模式。它保证了在系统中对于使用这个类的地方永远只有一个实例

所谓创建型模式，是针对于类的创建和使用过程中用到的设计模式，与其相对应的还有结构型、行为型

二、要素

• 构造方法私有化
• 提供一个全局访问点

构造方法私有化，是保证对于其他类对于这个类没办法通过new的方式进行创建；
与之对应的，其它对象想用到这个类，都是使用全局访问点(即静态方法)获取这个对象的引用;
一般来说，都对应着会有一个持有当前对象的静态引用变量，用以在静态方法中进行返回。

当然，对于单例模式，需要考虑到线程安全、反射、序列化、克隆等对于其影响

三、几种实现方式

下面就进入正题，来看一下单例的几种实现方式，进行对比，选取最适合自己的实现方式。

1. 饿汉式

public class Singleton {

    // 3. 此处是饿汉式的典型方式，在变量中直接new此对象
    private static Singleton singleton = new Singleton();

    // 1.构造方法私有化
    private Singleton(){}

    // 2.提供全局访问点
    public static Singleton getInstance(){
        return singleton;
    }
}

在类加载的时候就创建了此对象的实例，然后进行构造方法私有化，之后通过静态方法返回此对象的实例；
也正是因为在类加载的时候就已经创建了此实例，所以是线程安全的

2.懒汉式

public class Singleton {

    private static Singleton singleton = null;

    // 1.构造方法私有化
    private Singleton() {
    }

    // 2.提供全局访问点
    public static Singleton getInstance() {
        // 3. 懒汉式，只有在调用的时候才进行实例化
        if (null == singleton) {
            singleton = new Singleton();
        }
        return singleton;
    }

}

懒汉式是一种懒加载的方式，只有在用到当前对象的时候才创建当前对象，但是不是线程安全的。

3. 双重检查锁式

其实这种实现方式是对于懒汉的一种优化，保证了其是线程安全的

public class Singleton {

    private static Singleton singleton = null;
    // 零长度的byte数组对象创建起来将比任何对象都经济
    private final static byte[] LOCK;
    static {
        LOCK = new byte[0];
    }
    // 1.构造方法私有化
    private Singleton() {
    }
    // 2.提供全局访问点
    public static Singleton getInstance() {
        // 3. 懒汉式，只有在调用的时候才进行实例化
        if (null == singleton) {
            // 4.使用 synchronized 对于当前类进行加锁，保证线程安全
            synchronized (LOCK) {
                if (null == singleton) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

双重检查是指两次判断实例是否是null,锁是synchronized关键字,此处就保证了在多线程的情况下，实例也是唯一的情况

4.静态内部类实现

这种方式是利用了JVM类加载的原理进行实现，也是线程安全的

public class Singleton {


    // 1.构造方法私有化
    private Singleton() {
    }

    // 2.提供全局访问点
    public static Singleton getInstance() {
        return SingletonInner.singleton;
    }

    // 3.创建静态内部类
    private static class SingletonInner {
        static final Singleton singleton = new Singleton();
    }
}

这种方式即不会在类加载的时候初始化，也是线程安全的
外部类加载时并不需要立即加载内部类,只用在调用getInstance()方法的时候才会去加载内部类
原理解析参考 这个博客

5.枚举类实现

public class Singleton {
    // 1.构造方法私有化
    private Singleton() {
    }
    // 2.提供全局访问点
    public static Singleton getInstance() {
        return SingletonEnum.INSTANCE.getInstance();
    }
    //3. 创建枚举，在枚举创建的时候实例化单例
    private enum SingletonEnum {
        INSTANCE;

        private final Singleton instance;

        SingletonEnum() {
            instance = new Singleton();
        }

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

枚举类只会创建一次，而且枚举天生就是安全的并且不可反射和保证序列化单例

四、反射、序列化、克隆的影响

1. 避免反射的话，只需要在私有构造方法中进行处理就行，因为反射也是调用当前类的构造方法进行创建的

// 1.构造方法私有化
    private Singleton() {
        if (null != singleton) {
            throw new RuntimeException("不允许重复创建单例对象");
        }
    }

2. 避免通过反序列化创建对象的话，需要在类中添加方法

 private Object readResolve() {
        return singleton;
    }

具体原理不多解释，大家可以 参考这个博客

3. 克隆的影响

其实这个确实没办法完全避免，因为克隆的话是对于内存区域的拷贝；（由于枚举的特殊性，枚举类方式创建的单例可以避免）

五、最后

目前来说，创建单例的方式就这几种，枚举类创建的方式最为安全和避免其中的问题

如有错误，请指出，欢迎大家评论