Java 设计模式——单例模式（Singleton Pattern）

单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。频繁的创建和销毁的大对象使用单例模式可以减少内存和CPU开销。单例模式只有一个类实例，且单例模式没有接口，不能继承。

基本概念：

• 懒加载：在调用对象的时候才去初始化对象实例
• 线程安全：在拥有共享数据的多条线程并行执行的程序中，不会出现脏数据的情况

懒加载是对内存的合理利用，线程安全是保证业务逻辑和数据的正常，所以在实现单例的过程中，我们需要考虑这两点。

---

我们根据需求和实现来慢慢的了解单例模式：

需求：实现一个Socket连接类，要求因为业务需要，所以只能建立一个socket连接

分析：在没有学习单例模式之前，我们可能想到的是建立一个全局的Socket变量，每次需要适用Socket的时候，都调用这个变量。但是这样做，如果开发人员过多，是不是更有可能有多个人去做初始化且代码结构显得混乱。学习单例模式后会发现，其实单例模式能完美解决这个问题。

懒汉式（Lazy Singleton）

public class LazySingleton {
    private static LazySingleton mInstance;

    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        if (mInstance == null) {
            mInstance = new LazySingleton();
        }
        return mInstance;
    }
}

思考：如果我们有多个线程都需要使用到Socket连接，且可能同时调用getInstance(), 会出现什么结果呢？

解析：如果第一个线程刚好执行到 if (mInstance == null) 和 new LazySingleton() 之间，这个时候第二个线程刚好来调用getInstance()，然而这个时间点mInstance并没有被初始化，if (mInstance == null) 为true会继续执行new LazySingleton()，最后第一个线程和第二个线程都会执行new LazySingleton()，造成生成两个实例，从而违背了我们只需要一个实例的初衷。

总结：从以上分析，说明懒汉模式这种单例，不是线程安全的，而且在调用的时候才会去new，说明是懒加载。

懒汉线程安全式（Lazy Thread Safe Singleton）

大多数时候我们会需要线程安全的单例来满足我们的功能，那么是否可以通过关键字synchronized来保证线程安全呢，答案是肯定的。第一种方式如下：

public class ThreadSafeSingleton {

    private static ThreadSafeSingleton mInstance;

    private ThreadSafeSingleton() {
    }

    public static synchronized ThreadSafeSingleton getInstance() {
        if (mInstance == null) {
            mInstance = new ThreadSafeSingleton();
        }
        return mInstance;
    }
}

分析：这样保证每次调用getInstance()方法的时候都能等待上一个线程执行完成后，下一个线程才能调用，也能规避懒汉遇到的问题。但同步是需要付出代价的，每次调用getInstance()时都会触发synchronized，哪怕是ThreadSafeSingleton对象已经实例化，而我们new ThreadSafeSingleton()只需要调用一次,每次都触发synchronized有点得不偿失。

总结：从以上分析中说明这种方式属于懒加载且是线程安全的，但是由于每次都会触发synchronized，会影响效率。

双检锁/双重校验锁（DCL，即 double-checked locking）

继续优化synchronized，提升效率。

public class ThreadSafeSingleton {

    private static volatile ThreadSafeSingleton mInstance;

    private ThreadSafeSingleton() {
    }

    public static ThreadSafeSingleton getInstance() {
        if (mInstance == null) {
            synchronized (ThreadSafeSingleton.class) {
                if (mInstance == null) {
                    mInstance = new ThreadSafeSingleton();
                }
            }
        }
        return mInstance;
    }
}

这样，把同步放到方法中 if (mInstance == null) 后，这样如果对象已经实例化，则不会触发synchronized，只有在初始化的时候才会触发synchronized。可能会有一个疑问，为什么会出现两个 if (mInstance == null) ？ 第一个 if (mInstance == null) 类似懒汉式不是线程安全的，可能多个线程绕过这个判断，但如果mInstance已经初始化，这个方法的作用就体现出来了。同步模块之中if (mInstance == null) 的作用是，在多个线程同时跳过第一个 if (mInstance == null) 后，触发synchronized，等待执行，第一个线程会初始化ThreadSafeSingleton对象，那么加入判断第二个线程就不会再去重复初始化了。是不是完美解决了同步性能问题和线程安全问题。这种方法推荐使用。

注意：这里还加入了一个 volatile 关键字，用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值，这里使用volatile是保证每个线程读取到的mInstance都是最新的值。

volatile简单介绍：在JVM内存分配中，每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。而volatile关键字的作用正好是跳过线程栈，直接将变量值写入堆中。详细了解去Google java volatile。

总结：完美解决效率，线程安全和懒加载的问题，这种方式也是推荐使用的方式。

饿汉式（Hungary Singleton）

以上双重锁式单例已经能完美解决单例线程安全和效率问题，单例模式有很多种方式，这里再介另外一种饿汉式写法，已供了解。

public class HungrySingleton {
    private static HungrySingleton INSTANCE = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

分析：从代码中可以看出HungrySingleton实例在类加载的时候已经初始化，所以在多线程状态下，这种方式是线程安全的。但是如果我们在程序启动后没有马上使用HungrySingleton，如果HungrySingleton类过于庞大，由于JVM的类加载机制，HungrySingleton会提前被实例化放在内存中，这样会浪费内存。建议选择性使用。

JVM类加载机制：自行Google，O(∩_∩)O哈哈~（后续看看能不能补上）

总结：饿汉式是线程安全的，但不属于懒加载。

静态内部类（Static Inner Class）

我们要使用JVM相关的单例，那有没有办法像之前懒汉式一样，对饿汉式进行一些优化呢，答案是肯定的， 此方式是在饿汉式的基础上，结合JVM类加载机制特性进行的一次优化，从而实现线程安全和懒加载。

public class InnerClassSingleton {
    private InnerClassSingleton() {
    }

    public static InnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
}

分析：当类加载的时候会优先初始化static变量，故在加载InnerClassSingleton不会触发单例初始化，只有在调用getInstance()时，才会加载SingletonHolder类初始化单例实例。从而达到懒加载的目的。

总结：与双检锁方式实现原理不同，但是也能完美的实现线程安全，懒加载且不用担心synchronized效率问题，且实现更简单，推荐使用。

枚举式（Enum Singleton）

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，还没被广泛使用，这里也提出来了解一下。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

分析：这种方式利用的是Java枚举型特性，虽然这种方式是线程安全的，但是不是懒加载。

总结：单例模式在平时开发中会遇到很多，其实我们只需要选择一种方式实现就行了，推荐使用双检锁/双重校验锁式单例，其它方式可以作为了解。

工具

如果你用的IDE是Idea，那么恭喜你，强大的插件让你不在手动写单例模式了，下面就来介绍一款单例模式代码生成插件，名字叫Singleton。 

Preferences -> Plugins -> 搜索Singleton -> Install 安装->重启Idea。

接下来就可以自动生成单例模式的代码了，创建一个空类，右键 -> Generate -> Singleton -> 选择要生成的单例类型-> done.

源码地址