设计模式（二）——创建型模式——单例模式（Singleton）

单例模式（Singleton）

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

优点：节约系统资源、提高了系统效率，同时也能够严格控制客户对它的访问。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

实现思路：让类的构造方法私有化，同时提供一个静态方法去实例化这个类。

单例模式大致有四种写法，懒汉式、饿汉式、静态内部类和枚举。

1、饿汉式（立即加载方式）：

在声明对象就初始化。空间换时间。

优点：写法比较简单，在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

（1）静态变量[可用]：

public class Singleton {
    private static final Singleton instance= new Singleton();
    // 私有构造
    private Singleton() {}
    // 静态工厂方法
    public static Singleton getInstance() {
        return instance;
    }
}

（2）静态代码块[可用]：

public class Singleton {
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

2、懒汉式（延迟加载方式）：

在静态方法中初始化，实现懒加载。时间换空间。

（1）线程不安全：

public class Singleton{
    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
    private static Singleton single = null;
    // 私有构造
    private Singleton() {}
    //开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
    public static Singleton getInstance() {
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

（2）线程安全，同步方法，效率太低：

public class Singleton {
    private static Singleton instance = null;
    // 私有构造
    private Singleton() {}
    public static synchronized Singleton getInstance(){
      if(instance == null){
        instance = new Singleton();
       }
      return instance;
    }
}

（3）线程安全，同步代码块，双重检查[推荐用]，双检锁/双重校验锁（DCL）：

public class Singleton implements Serializable{
    private static Singleton instance = null;
    // 私有构造
    private Singleton() {}
    // 双重检查，当多个线程同时进入第一个if判断时，发生作用
    public static Singleton getInstance() {
        //仍然是线程不安全的，由于指令重排序，可能会得到“半个对象”,需要给变量加上volatile。
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance= new Singleton();
                }
            }
        }
        return instance;
    }
    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
    private Object readResolve() {
        return instance;
    }
}


/***************加上volatile*****************/
public class Singleton implements Serializable{
    //让修改值立即更新到主存
    private static volatile Singleton instance = null;
    // 私有构造
    private Singleton() {}
    // 双重检查，当多个线程同时进入第一个if判断时，发生作用
    public static Singleton getInstance() {
        //保证对象实例化后再执行时不再加锁，提高效率
        if (instance == null) {
            synchronized (Singleton.class) {
                //对象为空则创建
                if (instance == null) {
                    instance= new Singleton();//不是原子性操作
                    /**
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     *
                     * 123
                     * 132 A执行到3的步骤时，B线程进入到if判断
                     *     B // 此时lazyMan还没有完成构造，此时B if判断instance ！= null，直接返回instance，但是此时的instance还未执行构造方法
                     */
                }
            }
        }
        return instance;
    }
    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
    private Object readResolve() throws ObjectStreamException{
      return instance;
    }
}

voliate关键字的两个作用

1） 保证变量的可见性：当一个线程修改了变量的值，新的值会立刻同步到主内存当中。而其他线程读取这个变量的时候，也会从主内存中拉取最新的变量值。

2） 屏蔽指令重排序：指令重排序是编译器和处理器为了高效对程序进行优化的手段，它只能保证程序执行的结果时正确的，但是无法保证程序的操作顺序与代码顺序一致。这在单线程中不会构成问题，但是在多线程中就会出现问题。非常经典的例子是在单例方法中同时对字段加入voliate，就是为了防止指令重排序。

指令重排序：是指JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对现有的指令顺序进行重新排序。目的是为了在不改变程序执行结果的前提下，优化程序的运行效率。需要注意的是，这里所说的不改变执行结果，指的是不改变单线程下的程序执行结果。

3、登记式/静态内部类实现[推荐用]：

利用了类加载机制来保证初始化instance时只有一个线程，饿汉式中Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有通过显式调用getInstance方法时，才会显式装载SingletonHolder类，从而实例化instance。静态内部类的特点：当Singleton类装载的时候SingletonHolder是不会被装载的；当调用SingletonHolder里面的方法或者变量的时候，SingletonHolder才会被装载，而且只会装载一次，类的装载是线程安全的。

优点：避免了线程不安全，延迟加载，效率高。

public class Singleton{
    // 私有构造
    private Singleton() {}
    // 静态内部类
    private static class SingletonHolder{
        private static final Singleton single = new Singleton();
    }
    
    public static Singleton getInstance() {
        return SingletonHolder.single;
    }
}

4、枚举[推荐用]：

优点：借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

public class Singleton06 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);//结果为：true
        instance.doSomething();
    }
}

enum Singleton{
    INSTANCE;//默认调用无参数的构造方法，枚举的构造方法是private
    //在枚举类中也可以定义方法
    public void doSomething(){
        System.out.println("Hello World");
    }
}

总结：一般情况下，不建议使用懒汉式的第1种和第2种，建议使用饿汉方式。只有在要明确实现lazy loading（懒加载）效果时，才会使用静态内部类的方式和双检锁方式。如果涉及到反序列化创建对象时，推荐使用枚举方式。

实际应用：

（1）jdk中Runtime类

（2）RestTemplate

（3）线程池

（4）数据源

（5）spring中的sessionFactory等

使用注意事项

1）单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

2）当想实例化一个单例类的时候，必须要记住使用相应的获得对象的方法，而不是使用new；

3）单例模式使用场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）。