前言

单例模式 （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 ，所以同步代码块还需要再次判断一次。
• 静态内部类赋值实际是调用 方法，而虚拟机保证 方法使用锁，保证线程安全。