设计模式——单例模式

《Head First 设计模式》 学习笔记，码云同步更新中

如有错误或不足之处，请一定指出，谢谢~

目录

设计原则

• “依赖倒置”原则
• 未完待续…

设计模式

• 设计模式——策略模式
• 设计模式——装饰者模式
• 设计模式——观察者模式
• 设计模式——简单工厂
• 设计模式——工厂方法模式
• 设计模式——抽象工厂模式
• 设计模式——单例模式
• 未完待续…

单例模式（Singleton Pattern）

• 定义：
  • 例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
• 优点：
  • 节约系统资源，避免频繁创建销毁对象带来的开支
  • 保证对象的全局唯一性
  • 在类的实例化进程上有一定的灵活性
  • 进行扩展之后可以允许存在可变数目的实例
• 缺点：
  • 扩展困难
  • 一定程度上违反了“单一职责原则”
• 使用场景：
  • 系统要求有且只有一个对象实例，比如全局唯一序列号生成器，
  • 系统考虑到性能，避免某对象频繁创建销毁
  • 使用者除单例提供的单个访问点外，不允许通过其他途径访问实例。

实现单例模式的方法

饿汉式

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() { // 私有的构造函数，防止用new创建对象
    }

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

在第一次加载类时就初始化实例，当如果客户端一直没有使用，会造成性能浪费。也无法依赖参数或配置文件实例化。
简单，但不可取。

懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            return new Singleton();
        }
        return instance;
    }
}

采用了懒加载模式，只有当有人第一次使用该实例时才会初始化。
但有一个致命问题：线程不安全。当多个线程并行调用getInstance()方法时，会创建多个实例。

懒汉式（线程安全）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            return new Singleton();
        }
        return instance;
    }
}

为了解决线程安全问题，给getInstance()方法加上synchronized关键字。
但这种做法很不高效。因为实际上只有第一次调用时才需要同步，确保只会创建一个对象。
而这样做会让随后的所有调用都是同步的，也就是同一时间只有一个线程可以访问，会影响性能。

双重检验锁

public class Singleton {
    private volatile static Singleton instance; // 注意volatile修饰

    private Singleton() {
    }

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

可以看到，先进性第一次检验，通过则进入同步块。未避免多个线程同时进入同步块，需要在同步块内部进行第二次检验。
这样既保证了线程安全，又保证了性能（同步块只会在第一次实例化的时候执行）
但这里要注意一个问题，instance变量需要被volatile关键字修饰，原因是：
instance = new Singleton();
操作并非是原子性的，实际上JMM做了大概这3件事：

1. 给instance分配内存
2. 调用Singleton的工造函数，初始化成员变量
3. 将instance对象指向分配的内存空间。（在这一步之前instance还是null，执行之后就不再是null了）

而JMM会做重排序优化，也就是实际上的执行顺序有可能是1-3-2，而如果当线程A先将3执行完毕，还没执行2之前，另一个线程就来获取实例，
（instance已经不是null了，但还没有初始化），显然会报错。

注：此处JMM相关知识可以看我的另外一篇文章：深入理解Java内存模型

现在的做法看起来安全高效了，但别急，还有更好的方法实现。

静态内部类

public class Singleton {

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

    private Singleton() {
    }

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

当getInstance()第一次被调用时，第一次读取SingletonHolder.INSTANCE。这时候内部类SingletonHolder会被初始化。
初始化时会初始化静态域，从而创建Singleton实例，因为是静态域，只会初始化一次，并且由JMM保证线程安全。

这种方法线程安全，懒汉式实现，没有性能缺陷，不依赖JDK版本。

还有更好的。

枚举

public enum EasySingleton {
    /**
     * 实例
     */
    INSTANCE;

    public void doSomething(){

    }
}

使用时只需要EasySingleton.INSTANCE.doSomething();即可
枚举默认是线程安全的，还有一个最大的优势是，可以避免反序列化造成的重新创建对象。
因为Java规范中规定，每一个枚举类型极其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上做了特殊规定。
保证序列化、反序列化后的实例与序列化前相同。

总结

一般情况直接使用恶汉式即可，如有性能要求，可使用静态内部类或枚举。

参考资料

1. Jark’s Blog