八种单例模式

饿汉式静态常量（调用：静态方法）饿汉式静态代码块懒汉式线程不安全懒汉式线程安全，同步方法懒汉式线程安全，同步代码块双重检查静态内部类枚举

前言

首先我们先熟悉一个概念：懒加载 Lazy loading 懒加载：其实就是延时加载，即当对象需要用到的时候再去加载。

1、饿汉式 （静态常量）√

这种方式基于ClassLoader机制避免了多线程的同步问题。不过 instance在类装载是就实例化，在单例模式中大多数都是调用 getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方法（或者其他的静态方法）导致类装载，这时候初始化instance就没达到 lazy loading（懒加载） 的效果

优点与缺点：

优点：写法简单，就是在类装载的时候就完成实例化。避免了线程同步问题（没有多线程问题，早于线程创建）。 （为什么会是类装载就可以完成实例化？–传送门）

缺点：在类装载的时候就完成实例化，没有达到Lazy loading 的效果。从头到尾没有使用这个实例的话，会对内存造成浪费

结论：这种单例模式可用，但是造成内存的浪费

↓ 代码实现：

/* 饿汉式 （饥渴，上来就干） 技术：静态常量 */ public class StaticFinal { // 单例第一步：构造器私有化，外面不能new private StaticFinal() { System.out.println("实例化"); } // 2：本类内部创建 静态常量 显示赋值 private static final StaticFinal instance = new StaticFinal(); // 3:提供一个静态方法，返回实例对象 public static StaticFinal getInstance() { return instance; } } //测试类 public static void main(String[] args) { StaticFinal.getInstance(); }

2、 饿汉式（静态代码块）

优点、缺点如上结论：这种单例模式可用，但是造成内存的浪费

↓ 代码实现：

public class StaticBlock { private StaticBlock() { System.out.println("实例化"); } private static StaticBlock instance; static { instance = new StaticBlock(); System.out.println("静态代码块"); } public static StaticBlock getInstance() { return instance; } } //测试类 public static void main(String[] args) { StaticFinal.getInstance(); }

3、 懒汉式（线程不安全）

优点：起到了Lazy loading 的效果，但是只能在单线程下使用缺点：在多线程下，一个线程进入了 if条件的判断代码块中，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以多线程下这种方式不可用结论：在实际开发中，不要使用这种方式

↓ 代码实现：

public class ThreadUnsafe { // 1、首先接口私有化 private ThreadUnsafe() { } //2、创建私有静态变量 private static ThreadUnsafe instance; // 提供一个静态的公有方法，当使用到该方法时，才去创建 instance // 懒汉式 public static ThreadUnsafe getInstance() { if (instance == null) { instance = new ThreadUnsafe(); } return instance; } } //测试类 public static void main(String[] args) { for (int i = 0; i < 10; i++) { new Thread(()->{ ThreadUnsafe.getInstance(); }).start(); } }

4、 懒汉式（线程安全、同步方法）

优点：解决了线程不安全的问题缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了，方法进行同步效率太低了。结论：在实际开发中，不要使用这种方式 public class StaticSafe { private StaticSafe(){} private static StaticSafe instance ; public synchronized static StaticSafe getInstance(){ if(instance==null){ instance = new StaticSafe(); System.out.println(Thread.currentThread().getName() +"创建实例中。。。"); } return instance; } } // 测试 public static void main(String[] args) { new Thread(() -> { for (int i = 0; i < 10; i++) { StaticSafe.getInstance(); } }).start(); }

5、 懒汉式（线程不安全、同步代码块）

优点：本想是滴第四种（上面）实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的代码块缺点：但这种同步并不能起到线程同步的作用。跟第三种实现方式遇到的情形一致，加入一个线程进入了 if (instance == null) 判断语句块，那未来得及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例结论：在实际开发中，不要使用这种方式

↓ 代码实现：

public class ThreadUnsafe { // 1、首先接口私有化 private ThreadUnsafe() { } //2、创建私有静态变量 private static ThreadUnsafe instance; // 提供一个静态的公有方法，当使用到该方法时，才去创建 instance // 懒汉式 public static ThreadUnsafe getInstance() { if (instance == null) { synchronized (ThreadUnsafe.getInstance()){ instance = new ThreadUnsafe(); } } return instance; } } // 测试 public static void main(String[] args) { new Thread(() -> { for (int i = 0; i < 10; i++) { StaticSafe.getInstance(); } }).start(); }

6、 双重检查（测）DCL（double check lock）

优点：

Double-Check 概念是多线程开发中常使用到，如代码中所示，我们进行了俩次 if(instance==null) 检查，这样就保证线程安全了这样，实例化代码只用执行一次，后面再次访问时，判断 if(instance==null)，直接return 实例化对象，也避免反复进行方法同步线程安全；延迟加载；效率高结论：在实际开发中，推荐使用这种单例设计模式

↓ 代码实现：

public class DoubleCheck { private DoubleCheck() { System.out.println(Thread.currentThread().getName()); } private static volatile DoubleCheck INSTANCE; // 提供了一个静态的公有方法，加入双重检测代码，解决线程安全问题，同时解决懒加载问题 // 同时保证了效率 public static DoubleCheck getInstance() { if (instance == null) { synchronized (DoubleCheck.class) { if (instance == null) { instance = new DoubleCheck(); } } } return instance; } // 测试 public static void main(String[] args) { for (int i = 0; i < 10; i++) { new Thread(() -> { DoubleCheck.getInstance(); }).start(); } } }

7、静态内部类 √

这种方式采用了类装载的机制来保证初始化实例时只有一个线程静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程安全性，在类进行初始化时，别的线程是无法进入的优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高结论：在实际开发中，推荐使用 public class StaticInside { // 1.私有构造函数 private StaticInside(){} //2.静态内部类，该类中有一个静态属性 private static class SingletonInstance{ private static final StaticInside INSTANCE = new StaticInside(); } // 3.提供一个静态的公有方法，直接返回 public static StaticInside getInstance(){ // 调用静态内部类中的 静态变量 return SingletonInstance.INSTANCE; } }

8、枚举

/* * 不进可以解决线程同步，还可以防止反序列化 * */ public enum Enum1 { INSTANCE; public void m(){ // 业务方法 } } // 测试 public static void main(String[] args) { for (int i = 0; i < 10; i++) { new Thread(()->{ System.out.println(Enum1.INSTANCE.hashCode()); }).start(); } }