【深入理解设计模式】单例设计模式

单例设计模式

在这里插入图片描述

概念：

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。

单例设计模式是一种创建型设计模式，其主要目的是确保类在应用程序中的一个实例只有一个。这意味着无论在应用程序的哪个位置请求该类的实例，都将获得同一个实例。这种模式通常用于控制某些共享资源的访问，或者在整个应用程序中管理唯一的状态。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的实现：

单例设计模式分类两种：

饿汉式：类加载就会导致该单实例对象被创建
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

饿汉式实现方式：

饿汉式实现1 - 静态变量方式

/**
* @author OldGj 
* @version v1.0
* @apiNote 单例设计模式 - 饿汉式：静态变量实现
*/
public class Singleton {

   // 1.构造方法私有化
   private Singleton() {}

   // 2.在成员位置创建本类的对象
   private static final Singleton instance = new Singleton();

   // 3.对外界提供可以访问到自身创建的对象的静态方法
   public static Singleton getInstance(){
       return instance;
   }
}

注意：
该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

饿汉式实现2 - 静态代码块方式

拓展：静态代码块在类加载过程的初始化阶段执行。
类的加载过程分为：加载 -> 链接（验证，准备，解析） -> 初始化

/**
 * @author OldGj 
 * @version v1.0
 * @apiNote 单例设计模式 - 饿汉式：静态代码块实现
 */
public class Singleton {

    // 1.构造器私有化
    private Singleton(){}

    // 2.声明静态全局变量
    private static Singleton instance;

    // 3.在静态代码块中进行赋值
    static {
        instance = new Singleton();
    }

    // 4.对外提供可以获取本类对象的静态方法
    public static Singleton getInstance(){
        return instance;
    }
}

注意：
该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

饿汉式实现3 - 枚举

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

/**
* @author OldGj 
* @version v1.0
* @apiNote 单例模式 - 饿汉式 > 利用枚举实现 <
*/
public enum Singleton {
   INSTANCE;
}

注意：
枚举方式属于饿汉式方式。如果在不考虑饿汉式存在内存浪费问题的情况下，使用枚举类型创建单例模式是最好的单例实现方式，因为枚举类型是天然的线程安全的，并且实现方式简单，只会被加载一起，而且是所有单例实现方式中，唯一一种不会被破坏的实现方式。

懒汉式实现方式：

懒汉式实现1 - 会有线程安全问题

/**
* @author OldGj
* @version v1.0
* @apiNote 单例设计模式 - 懒汉式 > 线程不安全 <
*/
public class Singleton {

   // 1.构造器私有化
   private Singleton() {
   }

   // 2.在成员位置创建本类的对象
   private static Singleton instance;

   // 3.对外提供可以获取到本类对象的静态方法
   public static Singleton getInstance() {
       // 只有在instance变量还没有实例化对象的时候，才实例化一个对象
       if (instance == null) {
           // 线程1 -> 等待
           // 线程2，分配到CPU，实例化了一个Singleton实例并赋值给instance变量
           // 线程1，因为已经进入判断，因此线程1又实例化了一个Singleton对象，不符合单例模式
           instance = new Singleton();
       }
       return instance;
   }
}

注意：
该从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

懒汉式实现2 - synchronized同步锁解决线程安全问题

/**
 * @author OldGj 
 * @version v1.0
 * @apiNote 单例设计模式 - 懒汉式  > 线程安全 <
 */
public class Singleton {

    // 1.构造器私有化
    private Singleton (){}

    // 2.在成员位置声明Singleton类型的静态变量
    private static Singleton instance;

    // 3.对外提供一个可以获取本类对象的静态方法
    // 并且将该方法使用synchronized同步锁加锁，确保实例化过程中的线程安全
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }
}

注意：
该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

懒汉式实现3 - 双重检查锁

再来讨论一下懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式


/**
 * @author OldGj 
 * @version v1.0
 * @apiNote 单例设计模式 - 懒汉式 <b> > 双重检查锁模式 < <b/><br/>
 *          <p>多线程环境下，不会出现线程安全问题，也不会有性能问题*推荐使用*<p/>
 */
public class Singleton {

    // 1.构造器私有化
    private Singleton(){}

    // 2.在成员位置声明Singleton类型的静态变量并用volatile关键字修饰
    private static volatile Singleton instance;

    // 3.对外提供可以获取本类对象的静态方法，并在方法内采用双重检查锁保证线程安全
    public static Singleton getInstance(){
        // 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance==null){
            synchronized (Singleton.class){
                // 抢到锁之后再次判断是否为null
                if(instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

注意：
双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

懒汉式实现4 - 静态内部类方式

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

/**
 * @author OldGj 
 * @version v1.0
 * @apiNote 单例设计模式 - 懒汉式 > 静态内部类实现 <
 */
public class Singleton {
    /**
     * 静态内部类单例模式中实例由内部类创建，
     * 由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载,
     * 并初始化其静态属性。静态属性由于被 `static` 修饰，保证只被实例化一次，并且严格保证实例化顺序。
     */


    // 1.构造器私有化
    private Singleton() {}

    // 2.创建静态内部类，并且在静态内部类中创建外部类的实例
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 3.对外提供可以获得本类实例的静态方法
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}