单例模式

1. 定义

• 确保某一个类只有一个实例，而且自行实例化并向整个系统提供整个实例。

2. UML类图

3. 通用代码（饿汉式）

public class Singleton {

    private static final Singleton sSingleton = new Singleton();

    //限制产生多个对象
    private Singleton() {
    }

    //通过该方法获得实例对象
    public static Singleton getSingleton() {
        return sSingleton;
    }

    //类中其他方法，尽量是static
    public static void doSometing() {

    }
}

4. 关键点（非常重要）

• 私有构造函数。
• 暴露公有静态方法返回单例类唯一对象。
• 在多线程环境下确保单例类对象有且只有一个。

5. 优点

• 只有一个实例，减少内存开支。（频繁创建时）
• 只生成一个实例，减少系统性能开销。（一个对象需要比较多的资源时）
• 避免对资源的多重占用，以免对同一个资源文件同时操作。（比如：写文件时）
• 优化和共享资源访问。（可以在系统设置全局的访问点）

6. 缺点

• 没有接口，扩展困难，只能修改代码。疑问：为什么不增加接口呢？因为单例模式要求“自行实例化”，接口对单例模式没有意义。
• 对测试不利。并行开发环境中，单例模式没有完成，是不能进行测试的。
• 单例模式与单一职责原则有冲突。后者规定一个类应该只实现一个逻辑，是不是单例取决于环境。前者规定必须是单例而且没有规定只能有一个逻辑。

7. 使用场景

• 当要求一个类有且只有一个对象，出现多个对象就会发生“不良反应”时，比如访问I/O或者数据库等资源。
• 整个项目需要一个共享访问点或者共享数据。
• 工具类对象。

8. 注意事项（一）

在高并发的情况下，饿汉式不会出现产生多个实例的情况，但是懒汉式就要注意线程的同步问题，懒汉式代码如下：

public class Singleton {

    private static Singleton sSingleton = null;

    //限制产生多个对象
    private Singleton() {
    }

    //通过该方法获得实例对象
    public static Singleton getSingleton() {
        if (sSingleton == null) {
            sSingleton = new Singleton();
        }
        return sSingleton;
    }

}

该单例模式在低并发的情况下并不会出现问题，若并发量增大则可能出现多个实例！为什么会这样呢？

如一个线程A执行到sSingleton = new Singleton()，但是没有获得对象（对象初始化是需要时间的），第二个线程B也在执行，执行到（sSingleton == null）判断，那么线程B获得判断条件也是真，于是继续运行下去，线程A获得了一个对象，线程B也获得了一个对象，在内存中就出现两个对象。

解决线程不安全的方法有很多，可以在getSingleton方法前加sychronized关键字，也可以在getSingleton方法内增加sychronized来实现。优点是单例只有在使用时才会被实例化，在一定程序上节约了资源；缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销。

所以相比懒汉式，更加推荐饿汉式，当然各有利弊，下文会推荐几种适用的单例模式，别着急，接着往下看。

9. 注意事项（二）

除了担心高并发以外，还需要考虑对象的复制情况。

在Java中，对象默认是不可以被复制的，若实现Cloneable接口，实现clone方法，则可以直接通过对象复制方法创建一个新对象，对象复制是不用调用类的构造函数的，因此即使是私有的构造函数，对象仍然可以被复制。所以解决该问题的方法就是单例类不要实现Cloneable接口。

10. 推荐写法

• 饿汉式模式

public class Singleton {

    private static final Singleton sSingleton = new Singleton();

    //限制产生多个对象
    private Singleton() {
    }

    //通过该方法获得实例对象
    public static Singleton getSingleton() {
        return sSingleton;
    }

    //类中其他方法，尽量是static
    public static void doSometing() {

    }
}

优点：类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。这种方式基于类加载机制，避免了多线程的同步问题。

缺点：不能达到懒加载的效果，如果从始至终未使用过这个实例，则会造成内存的浪费。

推荐场景：单例模式经常使用的场景下，选择饿汉式。

• 双重检索模式（DCL）

public class Singleton {

    private static Singleton sSingleton = null;

    //限制产生多个对象
    private Singleton() {
    }

    //通过该方法获得实例对象
    public static Singleton getSingleton() {
        if (sSingleton == null) {
            synchronized (Singleton.class) {
                if (sSingleton == null) {
                    sSingleton = new Singleton();
                }
            }

        }
        return sSingleton;
    }

}

亮点：在getSingleton方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层判断则是为了在null的情况下创建实例。

分析：
sSingleton = new Singleton()这句话大致做了3件事情：
①：给Singleton的实例分配内存。
②：调用Singleton()构造函数，初始化成员字段。
③：将sSingleton对象指向分配的内存空间（此时sSingleton不是null了）
但是由于Java编译器允许处理器乱序执行等原因，执行顺序可能是1,2,3，还可能是1,3,2.如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候sSingleton因为已经在线程A内执行过了第三点，sSingleton已经是非空了，所以线程B直接取走sSingleton，再使用时就会出错，导致DCL失效。
为了避免这类事情的发生，JDK1.5之后调整了JVM,具体化了volatile关键字，只需要将sSingleton定义改成private volatile static Singleton sSingleton = null 就可以保证sSingleton对象每次都是从主内存中读取的，这样的话就可以使用DCL。

优点：资源利用率高，第一次执行getSingleton时单例对象才会被实例化。
缺点：第一次加载时反应稍慢。

推荐理由：资源利用率高！线程安全！绝大多数场景下可以保证单例对象的唯一性。

完整代码：

public class Singleton {

    private volatile static Singleton sSingleton = null;

    //限制产生多个对象
    private Singleton() {
    }

    //通过该方法获得实例对象
    public static Singleton getSingleton() {
        if (sSingleton == null) {
            synchronized (Singleton.class) {
                if (sSingleton == null) {
                    sSingleton = new Singleton();
                }
            }

        }
        return sSingleton;
    }

}

• 静态内部类单例模式（最推荐的）

DCL虽然解决了资源消耗、多余的同步、线程安全等问题，但是在高并发场景比较复杂的情况下依然会出现失效的问题，所以推荐使用静态内部类单例模式：

public class Singleton {

    //限制产生多个对象
    private Singleton() {
    }

    //通过该方法获得实例对象
    public static Singleton getInstance() {
        return SingletonHolder.sInstance;
    }

    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        private static final Singleton sInstance = new Singleton();
    }

}

优点：
1. 懒加载：
第一次加载Singleton类时并不会初始化sInstance，只有在第一次调用Singleton的getInstance方法时才会导致sInstance被初始化。
2. 线程安全和单例对象唯一性：
第一次调用Singleton的getInstance方法时会导致虚拟机加载SingletonHolder类，这种方式确保了线程安全，还保证了单例对象的唯一性。

推荐理由:懒加载、线程安全、单例对象唯一性。

• 枚举模式

public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("do sth.");
    }

    private Object readResolve() throws ObjectStreamException {
        return INSTANCE;
    }
}

优点：默认枚举实例的创建实线程安全的，并且在任何情况下它都是一个单例，包括序列化。

推荐理由：写法简单，甚至在反序列化的情况下，依然可以保证单例的唯一性。

• 容器模式

public class Singleton {

    private static Map<String, Object> objMap = new HashMap<String, Object>();

    private Singleton() {
    }

    public static void registerService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objMap.get(key);
    }

}

分析：在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

11. 特别注意

通过反序列化，上面几种单例模式都会出现
重新创建对象的情况，枚举不包括在内。

通过反序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而获得一个实例。及时构造函数是私有的，反序列化依然可以通过特殊途径去创建类的一个新的实例。

反序列化操作提供了一个很特别的函数，类中具有一个私有的、被实例化的方法readResolve，通过这个方法可以让开发人员控制对象的反序列化。

所以上述几个示例中如果要杜绝单例对象在被反序列化时重新生成对象，必须加入以下方法

private Object readResolve() throws ObjectStreamException {
        return sInstance;
    }

readResolve方法将sInstance对象返回，而不是默认的重新生成一个新的对象。