单例设计模式

  设计模式：是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

一、概念

1. 定义：单例设计模式，即：类在应用程序中保证只有且只有一个实例对象。
2. 好处：1）、提升运行效率    2）、实现数据共享

二、实现

• 懒汉模式：实例在第一次使用时创建
• 饿汉模式：实例在类装载时创建
  
  

1、懒汉式

1）、为了实现单例模式，需要控制类的构造器，将其构造器私有化，防止外界通过构造器直接创建对象

package com.wei.designp.singleton;

public class Singleton {
    /**
     * 1、构造器私有化，则其他对象不能通过构造器直接实例化该对象
     */
    private Singleton(){

    }
}

2）、需要对外提供公有的静态方法（getInstance）获取该类的对象，因为外界无法实例化该对象，所以需要通过将该方法设置为静态的

package com.wei.designp.singleton;

public class Singleton {
    /**
     * 1、构造器私有化，则其他对象不能通过构造器直接实例化该对象
     * 2、需要对外提供公有的静态方法（getInstance）获取该类的对象
     */

    private Singleton(){

    }

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

}

3）、设置一个静态的属性指向该实例对象，添加单例控制逻辑：若该属性为空则需要实例化之后返回，若该属性不为空则直接返回该属性指向的对象

package com.wei.designp.singleton;

public class Singleton {
    /**
     * 1、构造器私有化，则其他对象不能通过构造器直接实例化该对象
     * 2、需要对外提供公有的静态方法（getInstance）获取该类的对象
     * 3、设置一个静态的属性指向该实例对象，添加单例控制逻辑
     */

    private static Singleton singleton;  //指向已有对象

    private Singleton(){

    }

    public static Singleton getInstance(){
        //添加单例控制逻辑
        if (singleton == null){         //若该类尚未实例化，则先实例化对象后返回
             singleton = new Singleton();
        }           
        return singleton;
    }

}

4）、多线程情况下，若T1线程和T2线程同时执行到if (singleton == null)时，均判断为未空，则这两个线程均会执行singleTon = new Singleton();，从而创建多个实例对象，则会破坏单例模式；故需要通过synchronized关键字进行加锁。

package com.wei.designp.singleton;

public class Singleton {
    /**
     * 1、构造器私有化，则其他对象不能通过构造器直接实例化该对象
     * 2、私有的静态成员属性记录已有实例对象
     * 3、对外提供公有访问入口静态方法 getInstance，并添加控制逻辑
     * 4、多线程情况下，需要加锁
     */

    private static Singleton singleton;  //指向已有对象

    private Singleton(){

    }

    public static Singleton getInstance(){
        //添加单例控制逻辑
        synchronized (SingleTon.class){     //加锁，防止多线程下破坏单例模式
            if (singleton == null){         //若该类尚未实例化，则先实例化对象后返回
                singleton = new Singleton();
            }
        }
        return singleton;
    }

}

5）、使用双重检验（double-check）提高效率：在 步骤4）、的代码有严重的效率问题，即：线程每次调用getInstance方法执行到synchronized语句时都会进入阻塞等待；我们在此之前先检验一次singleton是否为空，若为空（实例未创建）则进入阻塞，若不为空（实例已经创建）则直接返回该实例对象，不进入阻塞等待。

package com.wei.designp.singleton;

public class Singleton {
    /**
     * 1、构造器私有化，则其他对象不能通过构造器直接实例化该对象
     * 2、私有的静态成员属性记录已有实例对象
     * 3、对外提供公有访问入口静态方法 getInstance，并添加控制逻辑
     * 4、多线程情况下，需要加锁
     * 5、使用双重检验（double-check）提高效率
     */

    private static Singleton singleton;  //指向已有对象

    private Singleton(){

    }

    public static Singleton getInstance(){
        //添加单例控制逻辑
        if (singleton == null){                 //双重验证，double-check 提高效率：若对象已经被创建，则直接返回该对象，不用进入阻塞等待
            synchronized (Singleton.class){     //加锁，防止多线程下破坏单例模式
                if (singleton == null){         //若该类尚未实例化，则先实例化对象后返回
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

}

6）、在singleton属性前使用volatile关键字，禁用指令重排。
  这段代码写到步骤5）、之后看起来已经完美无瑕了。当然，只是『看起来』，还是有小概率出现问题的。想要充分理解需要先弄清楚以下几个概念：原子操作、指令重排。

• 原子操作 （atomic）
  简单来说原子操作就是不可分割的最小的操作，举个例m = 6这个指令就具有原子性，假设之前m的值为2，在执行m = 6这个指令之后，m的值就变成了6，不存在m的值有其他中间状态，这就是原子操作。

• 指令重排 （happen-before）
  简单来说，就是计算机为了提高执行效率，会做的一些优化，在不影响最终结果的情况下，可能会对一些语句的执行顺序进行调整。比如，这一段代码：

int a;         //语句 1
a = 10;        //语句 2
int b = 5;     //语句 3
int c = a + b; //语句 4

正常来说是顺序执行的，但是由于指令重排的原因，因为不影响最终结果，可能实际的执行顺序为：1324、3124；而由于语句3和语句4不是原子操作，由它们拆分的原子指令还有可能重排指令——也就是说，对于非原子操作，在不影响最终结果的情况下，其拆分的原子操作可能排列执行顺序。

再回头看看我们的单例模式代码，主要在singleton = new Singleton();语句上，这并非是一个原子操作，其在jvm中大概拆分为一下三步骤：
  1. 给singleton 分配内存；
  2. 调用Singleton 的构造器初始化成员变量，实例化
  3. 将singleton 对象指向分配的内存空间（执行完此步骤，singleton才是非null）

所以，以上语句真正的执行顺序可能是1-2-3，也有可能1-3-2,；若是某个线程按照后者执行，则会存在 【 singleton为非null但是其指向的对象未完成实例化】 的状态，即2-3之间。且若此时其他线程访问到if (singleton == null)时会认为singleton为非null从而返回未实例化成功的对象进行访问，从而出错。

解决方案：在singleton 属性前加上volatile 关键字

package com.wei.designp.singleton;

public class Singleton {
       /**
     * 1、构造器私有化，则其他对象不能通过构造器直接实例化该对象
     * 2、私有的静态成员属性记录已有实例对象
     * 3、对外提供公有访问入口静态方法 getInstance，并添加控制逻辑
     * 4、多线程情况下，需要加锁
     * 5、使用双重检验（double-check）提高效率
     * 6、在`singleton`属性前使用`volatile`关键字，禁用指令重排
     */

    private static volatile Singleton singleton; //volatile关键字禁止指令重排，防止singleton未完成写操作之前，对它进行读操作

    private Singleton(){

    }

    public static Singleton getInstance(){
        //添加单例控制逻辑
        if (singleton == null){                 //双重验证，double-check 提高效率：若对象已经被创建，则直接返回该对象，不用进入阻塞等待
            synchronized (Singleton.class){     //加锁，防止多线程下破坏单例模式
                if (singleton == null){         //若该类尚未实例化，则先实例化对象后返回
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

}

volatile关键字的一个作用是禁止指令重排，把instance声明为volatile之后，对它的写操作就会有一个内存屏障，这样，在它的赋值完成之前，就不用会调用读操作。

注意：volatile阻止的不是singleton = new Singleton()这句话内部[1-2-3]的指令重排，而是保证了在一个写操作（[1-2-3]）完成之前，不会调用读操作（if (instance == null)）。

2、饿汉式

根据定义

package com.wei.designp.singleton;

public class Singleton2 {
    //在类加载时，就会实例化
    private static Singleton2 singleton2 = new Singleton2();

    private Singleton2(){

    }

    public Singleton2 getInstance(){
        return singleton2;
    }
}

3、优劣

懒汉式——优点：节省资源； 缺点：代码复杂，多线程、指令重排、双重验证等问题

饿汉式——优点：代码简单易实现，没有多线程的问题；缺点：由于instance的初始化是在类加载时进行的，如果初始化太早，就会造成资源浪费。当然，如果所需的单例占用的资源很少，并且也不依赖于其他数据，那么这种实现方式也是很好的。

本文参考：https://blog.csdn.net/weixin_37817685/article/details/80261549