第二章_单例模式
1.单例模式定义
采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)
简要定义：类在内存中只能存在一个实例对象
2.单例模式创建方法
共有5种单例模式创建方法，分别为饿汉式、懒汉式、双重检验锁、静态内部类、以及枚举创建类对象方法
2.1饿汉式
通俗理解：不饿就点外卖
2.1.1定义
类内部直接创建出类的实例，然后用private私有化，对外只用静态方法（返回该实例）暴露
2.1.2创建步骤
- 构造器私有化
- 类的内部创建对象（直接创建对象了）
- 向外暴露一个静态的公共方法：返回该类的对象
2.1.3举例
该类的实例有两种创建方法：静态成员变量、静态代码块
（1）静态成员变量
class Singleton {
//私有化构造器
private Singleton() {
}
//内部创建对象实例
private final static Singleton instance = new Singleton();
//对外公有的静态方法
public static Singleton getInstance() {
return instance;
}
}
（2）静态代码块
class Singleton {
//静态代码块
//私有化构造器
private Singleton() {
}
//内部创建对象实例
private static Singleton instance;
static {
// 在静态代码块中，创建单例对象
instance = new Singleton();
}
//对外公有的静态方法
public static Singleton getInstance() {
return instance;
}
}
2.1.4小结
| 优点 | 缺点 |
|---|---|
| 写法简单，在类装载的时完成实例化，避免了线程同步问题 | 类装载时完成实例化，没有达到LazyLoading的效果，若该实例从未使用，则会造成内存浪费 |
2.2懒汉式
通俗理解：饿了才点外卖
2.2.1定义
在需要调用的时候再创建类的实例化
2.2.2创建步骤
- 构造器私有化
- 向外暴露一个静态的公共方法：里面创建该类的对象
2.2.3举例
该类的实例有两种创建方法：线程不安全和线程安全
（1）线程不安全
起到了懒加载效果，但是只能在单线程使用，多线程会不安全，因为当多个线程并发同时判断instance为空时，就会相应的实例化多个对象。
class Singleton {
//线程不安全
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
//调用时才实例化对象，懒汉式
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
（2）线程安全
使用synchronized关键字上锁。 这样虽然解决了线程安全，但其实实例化操作只做一次，而获取实例(即getInstance)的操作是很多次的，把调用的方法加上同步，会大大降低效率。
class Singleton {
//线程安全
private static Singleton instance;
private Singleton() {
}
//synchronized同步处理
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
2.2.4小结
| 优点 | 缺点 |
|---|---|
| 优点：第一次调用才初始化，避免内存浪费 | 必须加锁 synchronized 才能保证单例，但加锁会影响效率 getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。 |
2.3双重检验锁
2.3.1定义
（1）由来
懒汉式使用线程安全的方法，使用了synchronized关键字，并且加锁其实只需要在第一次初始化的时候用到，之后的调用都没必要再进行加锁。来创建类的对象效率低
（2）解决及步骤
先判断对象是否已经被初始化，再决定要不要加锁。
- 检查变量是否被初始化(不去获得锁)，如果已被初始化则立即返回。
- 获取锁。
- 再次检查变量是否已经被初始化，如果还没被初始化就初始化一个对象。
public class Singleton {
private static Singleton uniqueSingleton;
private Singleton() {
}
public Singleton getInstance() {
if (null == uniqueSingleton) {
synchronized (Singleton.class) {
if (null == uniqueSingleton) {
uniqueSingleton = new Singleton(); // error
}
}
}
return uniqueSingleton;
}
}
双重检查：如果多个线程同时了通过了第一次检查，并且其中一个线程首先通过了第二次检查并实例化了对象，那么剩余通过了第一次检查的线程就不会再去实例化对象。
（3）隐患
上述写法看似解决了问题，但是有个很大的隐患。实例化对象的那行代码（标记为error的那行），实际上可以分解成以下三个步骤：
- 分配内存空间
- 初始化对象
- 将对象指向刚分配的内存空间
但是有些编译器为了性能的原因，可能会将第二步和第三步进行重排序，顺序就成了：
- 分配内存空间
- 将对象指向刚分配的内存空间
- 初始化对象
现在考虑重排序后，两个线程发生了以下调用：
| Time | Thread A | Thread B |
|---|---|---|
| T1 | 检查到uniqueSingleton为空 |
|
| T2 | 获取锁 | |
| T3 | 再次检查到uniqueSingleton为空 |
|
| T4 | 为uniqueSingleton分配内存空间 |
|
| T5 | 将uniqueSingleton指向内存空间 |
|
| T6 | 检查到uniqueSingleton不为空 |
|
| T7 | 访问uniqueSingleton（此时对象还未完成初始化） |
|
| T8 | 初始化uniqueSingleton |
在这种情况下，T7时刻线程B对uniqueSingleton的访问，访问的是一个**初始化未完成**的对象。
2.3.2正确举例
注意：需要用到关键字volatile，防止指令重排。如果不用volatile关键字，就会和线程不安全情形一样，在if判断那会有并发。
class Singleton {
//双重检查
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if(instance == null) {
//判断是否实例化
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance; //否则直接return
}
}
2.3.3小结
既实现了懒加载，又保证了线程安全。
2.4静态内部类
2.4.1定义
静态内部类在外部类装载时不会实例化，当调用的时候才会装载并实例化，且JVM保证了其装载时的线程安全性。也能保证懒加载和线程安全，有点像自带版的双重检查。
class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
//静态内部类,包含一个静态属性：Singleton
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
//对外公有的静态方法，直接返回SingletonInstance.INSTANCE
public static synchronized Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
2.5枚举
其实，使用枚举也能实现单例模式，不仅能避免多线程同步问题，也能防止反序列化重新创建新的对象。
enum Singleton {
INSTANCE; //属性
public void say() {
System.out.println("记得三连~");
}
}
3.小结
1、当一个类的对象只需要或者只可能有一个时，应该考虑单例模式。
2、如果一个类的实例应该在JVM初始化时被创建出来，应该考虑使用饿汉式。
3、如果一个类的实例不需要预先被创建，也许这个类的实例并不一定能用得上，也许这个类的实例创建过程比较耗费时间，也许就是真的没必要提前创建。那么应该考虑懒汉式。
4、在使用懒汉式单例的时候，应该考虑到线程的安全性问题。
