目录
  • 前言
  • 饿汉单例
  • 懒汉单例
    • 非线程安全的懒汉单例
    • 加同步锁的懒汉单例
  • 双重检验懒汉单例
    • 静态内部类
      • 静态内部类为什么是线程安全
    • 总结

      前言

      单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

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

      饿汉单例

      是否多线程安全：是

      是否懒加载：否

      正如名字含义，饿汉需要直接创建实例。

      public class EhSingleton {
    private static EhSingleton ehSingleton = new EhSingleton();
    private EhSingleton() {}
    public static EhSingleton getInstance(){
        return ehSingleton;
    }
}

      缺点： 类加载就初始化，浪费内存

      优点： 没有加锁，执行效率高。还是线程安全的实例。

      懒汉单例

      懒汉单例，在类初始化不会创建实例，只有被调用时才会创建实例。

      非线程安全的懒汉单例

      是否多线程安全：否

      是否懒加载： 是

      public class LazySingleton {
    private static LazySingleton ehSingleton;
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        if (ehSingleton == null) {
            ehSingleton = new LazySingleton();
        }
        return ehSingleton;
    }
}

      实例在调用 getInstance 才会创建实例，这样的优点是不占内存，在单线程模式下，是安全的。但是多线程模式下，多个线程同时执行 if (ehSingleton == null) 结果都为 true，会创建多个实例，所以上面的懒汉单例是一个线程不安全的实例。

      加同步锁的懒汉单例

      是否多线程安全：是

      是否懒加载： 是

      为了解决多个线程同时执行 if (ehSingleton == null) 的问题，getInstance 方法添加同步锁，这样就保证了一个线程进入了 getInstance 方法，别的线程就无法进入该方法，只有执行完毕之后，其他线程才能进入该方法，同一时间只有一个线程才能进入该方法。

      public class LazySingletonSync {
    private static LazySingletonSync lazySingletonSync;
    private LazySingletonSync() {}
    public static synchronized LazySingletonSync getInstance() {
        if (lazySingletonSync == null) {
            lazySingletonSync =new LazySingletonSync();
        }
        return lazySingletonSync;
    }
}

      这样配置虽然保证了线程的安全性，但是效率低，只有在第一次调用初始化之后，才需要同步，初始化之后都不需要进行同步。锁的粒度太大，影响了程序的执行效率。

      双重检验懒汉单例

      是否多线程安全：是

      是否懒加载：是

      使用 synchronized 声明的方法，在多个线程访问，比如A线程访问时，其他线程必须等待A线程执行完毕之后才能访问，大大的降低的程序的运行效率。这个时候使用 synchronized 代码块优化执行时间，减少锁的粒度。

      双重检验首先判断实例是否为空，然后使用 synchronized (LazySingletonDoubleCheck.class) 使用类锁，锁住整个类，执行完代码块的代码之后，新建了实例，其他代码都不走 if (lazySingletonDoubleCheck == null) 里面，只会在最开始的时候效率变慢。而 synchronized 里面还需要判断是因为可能同时有多个线程都执行到 synchronized (LazySingletonDoubleCheck.class) ，如果有一个线程线程新建实例，其他线程就能获取到 lazySingletonDoubleCheck 不为空，就不会再创建实例了。

      public class LazySingletonDoubleCheck {
    private static LazySingletonDoubleCheck lazySingletonDoubleCheck;
    private LazySingletonDoubleCheck() {}
    public static LazySingletonDoubleCheck getInstance() {
        if (lazySingletonDoubleCheck == null) {
            synchronized (LazySingletonDoubleCheck.class) {
                if (lazySingletonDoubleCheck == null) {
                    lazySingletonDoubleCheck = new LazySingletonDoubleCheck();
                }
            }
        }
        return lazySingletonDoubleCheck;
    }
}

      静态内部类

      是否多线程安全：是

      是否懒加载：是

      外部类加载时，并不会加载内部类，也就不会执行 new SingletonHolder()，这属于懒加载。只有第一次调用 getInstance() 方法时才会加载 SingletonHolder 类。而静态内部类是线程安全的。

      静态内部类为什么是线程安全

      静态内部类利用了类加载机制的初始化阶段 方法，静态内部类的静态变量赋值操作，实际就是一个 方法，当执行 getInstance() 方法时，虚拟机才会加载 SingletonHolder 静态内部类，

      然后在加载静态内部类，该内部类有静态变量，JVM会改内部生成方法，然后在初始化执行方法 —— 即执行静态变量的赋值动作。

      虚拟机会保证 方法在多线程环境下使用加锁同步，只会执行一次 方法。

      这种方式不仅实现延迟加载，也保障线程安全。

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

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

      总结

      • 饿汉单例类加载就初始化，在没有加锁的情况下实现了线程安全，执行效率高。但是无论有没有调用实例都会被创建，比较浪费内存。
      • 为了解决内存的浪费，使用了懒汉单例，但是懒汉单例在多线程下会引发线程不安全的问题。
      • 不安全的懒汉单例，使用 synchronized 声明同步方法，获取实例就是安全了。
      • synchronized 声明方法每次线程调用方法，其它线程只能等待，降低了程序的运行效率。
      • 为了减少锁的粒度，使用 synchronized 代码块，因为只有少量的线程获取实例，实例是null，创建实例之后，后续的线程都能获取到线程，也就无需使用锁了。可能多个线程执行到 synchronized ，所以同步代码块还需要再次判断一次。
      • 静态内部类赋值实际是调用 方法，而虚拟机保证 方法使用锁，保证线程安全。
      声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。