概述

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

单例模式有 3 个特点：

• 单例类只有一个实例对象；
• 该单例对象必须由单例类自行创建；
• 单例类对外提供一个访问该单例的全局访问点；

在很多比较大型的程序中，全局变量经常被用到。如果不用全局变量，那么在使用到的模块中，都需要用参数将全局变量传入，这是非常麻烦的。虽然要减少使用全局变量，但是如果需要，还是要用。单例模式就是对传统的全局的一种改进。单例可以做到延时实例化，即在需要的时候才进行实例化。针对一些大型的类，延时实例化是有好处的。

实现

饿汉式单例

/**
 * 饿汉式单例
 * 线程安全
 */
public class Singleton1 {

    // jvm保证在任何线程访问instance静态变量之前一定先创建了此实例
    private static Singleton1 instance = new Singleton1();

    // 私有化构造方法，保证外界无法直接实例化
    private Singleton1() {
    }

    // 提供全局访问点获取唯一的实例
    public static Singleton1 getInstance() {
        return instance;
    }
}

• 优点：没有加锁，执行效率会提高。
• 缺点：类加载时就初始化，浪费内存。
• 场景：这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况。但是，如果单例占用的内存比较大，或单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了，这时候就需要用到懒汉模式进行延迟加载。

懒汉式单例

/**
 * 双重检查单例(懒汉式)
 * 线程安全
 * 单例实例在第一次使用时进行创建
 */
public class Singleton2 {

    private volatile static Singleton2 instance = null;

    // 私有化构造函数
    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            // 多线程可达，可能存在A实例化释放锁后，阻塞在此的B获得同步锁，所以此处需要双重检测
            synchronized (Singleton2.class) {
                if (instance == null) {
                    // 此处的执行顺序期望如下:
                    // 1. memory = allocate() 分配对象的内存空间
                    // 2. ctorInstance() 初始化对象
                    // 3. instance = memory 设置instance指向刚分配的内存
                    // 如果不用volatile修饰变量, 2、3指令可能重排，导致获取未初始化的对象
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

• 优点：第一次调用才初始化，避免内存浪费。
• 缺点：必须加锁synchronized才能保证单例，(静态同步方法实现的懒汉式)加锁会影响效率。

登记式单例

/**
 * 静态内部类单例(登记式、延迟加载)
 */
public class Singleton3 {

    private Singleton3() {
    }

    /**
     * 静态内部类
     * 在第一次调用getInstance方法之前，SingletonWrapper类是没有被加载的，因为它是一个静态内部类。
     * 当有线程第一次调用getInstance的时候，SingletonWrapper就会被class loader加载进JVM，在加载的同时，执行instance的初始化。
     * 所以，这种写法，仍然是一种懒汉式的单例类。
     */
    private static class SingletonWrapper {
        private static final Singleton3 instance = new Singleton3();
    }

    /**
     * 为什么这样写就是线程安全的呢？
     * 因为类的加载的过程是单线程执行的。它的并发安全是由JVM保证的。
     * 所以，这样写的好处是在instance初始化的过程中，由JVM的类加载机制保证了线程安全，
     * 而在初始化完成以后，不管后面多少次调用getInstance方法都不会再遇到锁的问题了。
     *
     * @return
     */
    public static Singleton3 getInstance() {
        return SingletonWrapper.instance;
    }
}

• 优点: 内部类只有在外部类被调用才加载，产生SINGLETON实例；又不用加锁。此模式有上述两个模式的优点，屏蔽了它们的缺点，是推荐的单例模式。
• 缺点: 在实例需要序列化的场景下，反射和序列化会破坏单例，这是懒汉式、饿汉式和登记式共同存在的缺陷。

枚举单例

/**
 * 枚举单例
 * 线程安全
 */
public class Singleton4 {

    // 私有构造函数
    private Singleton4() {

    }

    public static Singleton4 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    // 枚举实例是static final类型的，也就表明只能被实例化一次。
    // 在调用构造方法时，我们的单例被实例化
    private enum Singleton {

        INSTANCE;

        private Singleton4 singleton;

        // JVM保证这个方法绝对只调用一次
        Singleton() {
            singleton = new Singleton4();
        }

        public Singleton4 getInstance() {
            return singleton;
        }
    }
}

• 枚举提供了序列化机制，推荐的最佳实现方式

反射和反序列化对单例的影响

通过反射来实例化类

/**
 * 用反射来获得实例
 */
public class Singleton5 {

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Singleton1> clz = Singleton1.class;
        Constructor<Singleton1> constructor = clz.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton1 reflectInstance = constructor.newInstance();
        Singleton1 instance = Singleton1.getInstance();
        System.out.println(reflectInstance == instance); // false
    }
}

结果输出false，说明reflectInstance和instance不是同一个对象。(==比较的是实例对象的内存地址)

通过反序列化来实例化类

/**
 * 反序列化来获得实例
 */
public class Singleton6 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 单例(此处对单例进行修改，实现Serializable接口)
        Singleton1 singleton = Singleton1.getInstance();

        // 序列化
        FileOutputStream fos = new FileOutputStream("Singleton1.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(singleton);
        oos.flush();
        fos.close();
        oos.close();

        // 反序列化
        FileInputStream fis = new FileInputStream("Singleton1.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Singleton1 instance = (Singleton1) ois.readObject();
        fis.close();
        ois.close();

        // 对比
        System.out.println(singleton == instance); // false

    }
}

结果输出false，说明singleton和instance指向不同对象。

如何避免单例被破坏

修改单例类，解决反序列化的问题

/**
 * 饿汉式单例
 * 线程安全
 */
public class Singleton1 implements Serializable {

    // jvm保证在任何线程访问instance静态变量之前一定先创建了此实例
    private static Singleton1 instance = new Singleton1();

    // 私有化构造方法，保证外界无法直接实例化
    private Singleton1() {
    }

    // 提供全局访问点获取唯一的实例
    public static Singleton1 getInstance() {
        return instance;
    }

    //该方法在反序列化时会被调用，该方法不是接口定义的方法，有点儿约定俗成的感觉
    protected Object readResolve() throws ObjectStreamException {
        System.out.println("调用了readResolve方法！");
        return instance;
    }
}

结果输出

调用了readResolve方法！
true

应用场景

单例模式可以避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间。有以下场景的特点即可使用单例。

当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如数据库的连接池、zK分布式锁、工具类等。

当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

公众号 【当我遇上你】