目录

前言

饿汉式

懒汉式

Double_check

 volatile + double_check

Holder方式

 枚举

---

前言

        单例设计模式GOF23中设计模式中最常用的设计模式之一, 单例设计模式提供了多线程环境下的保证唯一实例性的解决方案, 虽然简单, 但是实现单例模式的方式多种多样, 因此需要从多个维度去评价: 

• 线程安全
• 性能
• 懒加载

懒加载的好处是啥? 

提高页面加载速度：通过仅在需要时加载资源，懒加载可以减少初次加载时的资源量，使页面更快地呈现给用户。

节省带宽：只有当用户真正需要时才加载资源，这样可以节省不必要的带宽使用，特别是对于那些需要大量数据或高分辨率图片的应用。

提升用户体验：通过延迟加载，可以让用户更快地看到页面的主要内容，从而提高用户的满意度和体验。

减少服务器负载：懒加载可以减少一次性加载大量资源的需求，从而减少服务器的负载，优化服务器性能。

优化移动端性能：对于移动设备，网络连接通常较慢且不稳定，懒加载可以显著提高移动端的页面加载速度和性能。

节省系统资源：懒加载可以避免不必要的资源消耗，减少浏览器和设备的内存使用，尤其是在处理大量数据或复杂页面时。

饿汉式

public class TestMain {// 定义的时候直接初始化private static TestMain instance = new TestMain ();// 提供get方法public static TestMain getInstance() {return instance;}// 私有化构造方法private TestMain() {}
}

        在类加载过程中提到过, instance作为类变量, 在类的初始化的过程中, 会被收集到<cinit>()反方法中, 该方法每个类只会执行一次, 100%保证同步, 因此在使用instance的过程中, instance不可能会被实例化两次

        但是, 这也正是因为是在类初始化的时候就已经存在, 那么就表明, 这个instance实例在完成初始化之后, 并存储在内存空间之后, 并不会立即就会被使用到, 那么就会在内存中驻留一个时间间隔, 这个时间间隔带来的成本增加需要通过量化, 不能一概而论

        例如如果instance实例的内存消耗小, 那么饿汉式也未免不是一种良好的解决方案, 虽然他不支持懒加载.

        对于这个getInstance方法, 没有加任何锁, 因此没有其他的性能消耗, 速度快

懒汉式

        所谓懒汉, 就是我很懒, 我只有在使用类实例的时候才去创建, 可以避免类在初始化的时候就提前去创建.

代码如下: 

public final class Test {private static  Test instance = null;private Test() {}public synchronized static Test getInstance() {if (null == instance) {instance = new Test ();}return instance;}
}

        当前方法的getInstace, 每次进入这个方法之前都会获取这个类的Class对象, 然后加锁, 但是我每次调用getIsntace都需要拿到一次锁, 这样性能不高. 同一个时刻只能由一个线程能拿到这个instance实例. 

为了避免上述情况, 我们考虑降低这个锁的粒度: 

你似乎可以这样写: 

public final class Test {private static  Test instance = new Test ();private Test() {}public  static Test getInstance() {synchronized (Test.class) {if (instance == null) {instance = new Test ();}return instance;}}
}

        但是这样写, 好像每次getInstance获取实例还是需要拿到锁, 还是会产生额外的锁竞争消耗 , 但是你仔细分析其实不难得知, 我除了第一次拿的时候需要初始化, 其他的时候, 都不需要初始化, 直接返回就行了, 于是你写出了这样的代码: 

public final class Test {private static  Test instance = new Test ();private Test() {}public  static Test getInstance() {if (instance == null) {instance = new Test ();}return instance;}}
}

但是第一次的时候会存在多线程风险, 也就是可能会存在多次给instance赋值的情况.... 

于是为了线程安全, 就给他加了锁, 如下: 

public final class Test {private static Test instance = new Test ();private Test() {}public static Test getInstance() {if (instance == null) {synchronized (Test.class) {instance = new Test ();}}return instance;}}

 但是这样似乎并不安全, 如果有两个线程都进入了这个if判断中, 同时判断了这个instance为null都准备拿锁进行实例化, 假设是线程1拿到锁, 之后instance 被初始化, 然后被返回, 释放锁后, 线程2又走了一遍实例化的过程, 因此这个instance就被实例化了两次, 也就没有保障单列模式. 

于是就有了下面这种写法. 

Double_check

        不再在方法上加锁, 我们在方法内部使用锁块来进行加锁, 降低粒度. 如下: 

public final class Test {private static Test instance = null;private Test() {}public static Test getInstance() {if (instance == null) {synchronized (Test.class) {if (instance == null)instance = new Test ();}}return instance;}}

 volatile + double_check

public final class Test {private static Test instance = null;Object var1;Object var2;private Test() {}public static Test getInstance() {if (instance == null) {synchronized (Test.class) {if (instance == null)instance = new Test ();}}return instance;}public static void setInstance(Test instance) {Test.instance = instance;}public Object getVar1() {return var1;}public Object getVar2() {return var2;}}

但是同时这个方法还存在一个问题, 都知道java的内存模型中每个线程都有自己的工作内存,. 变量都是暂存在工作内存中, 对工作内存中修改变量, 如果没有的就去内公共内存中去读取, 那么档期使用这种方法更新的时候, 其实其他线程是看不到第一个线程对其的修改. 

除此之外, 上述的doublecheck也不一定安全, 看看上面的一个案例

        在没有volatile的情况下，编译器可能会将instance = new Test();这行代码拆分为多个操作：1) 分配内存给instance；2) 调用Test的构造函数来初始化对象；3) 将instance指向分配的内存。如果没有适当的同步措施，这些操作的执行顺序可能会被重排序，比如先执行步骤1和3，再执行步骤2。这样，在步骤2完成之前，其他线程就可能看到非空的instance引用，但此时对象可能还未被完全初始化，从而导致程序出错。 

代码如下: 

public final class Test {private volatile static Test instance = null;Object var1;Object var2;private Test() {}public static Object getInstance() {if (instance == null) {synchronized (Test.class) {if (instance == null)instance = new Test();}}return instance;}public static void setInstance(Test instance) {Test.instance = instance;}public Object getVar1() {return var1;}public Object getVar2() {return var2;}}

Holder方式

在讲解java的jvm类加载机制的时候提到过: 

可以利用这个特性, 在需要实现单例模式的类中 添加一个静态内部类, 此时只要使用到了这个静态内部类里面的静态变量, 就会执行这个类的初始化, 但是后面无论如何 访问多少次, 就不再初始化了, 这就保证了单例模式的线程安全, 同时实现了懒加载, 重复获取也没有锁竞争. 

public final class Test {private Test() {}private static class Holder {private static final Test INSTANCE = new Test();}public static Test getInstance() {return Holder.INSTANCE;}}

 枚举

        effect java力荐方式: 

在Java中，使用枚举（Enum）来实现单例模式是一种既简单又高效的方法。枚举类型在Java中是一种特殊的类，它默认就是单例的，并且线程安全。这是因为JVM保证了枚举实例的唯一性，并且在枚举的任何地方访问枚举实例时，都不需要同步

public enum SingletonEnum {  INSTANCE;  // 可以在这里添加方法  public void doSomething() {  System.out.println("Doing something...");  }  // 示例：添加私有字段和方法  private Singleton instance;  public void setData(Singleton instance) {  this.instance= instance;  }  public Singleton getData() {  return instance;  }  }

其中: 

SingletonEnum instance1 = SingletonEnum.INSTANCE;  
SingletonEnum instance2 = SingletonEnum.INSTANCE;  

instance1和instance2是相同的实例.

当然这种方式不是懒加载的, 如果你想使用懒加载, 那么你可以使用静态内部类类似的加载机制: 

java的枚举类型和静态内部类一样, 只有在第一次被引用时会被加载和初始化，因此 EnumHolder 只有在调用 getInstance() 方法时才会被加载

public final class Test {private Test() {}private enum EnumHolder {INSTANCE;private Test test;EnumHolder() {test = new Test();}private Test getTest() {return test;}}// 调用该方法会主动使用 EnumHolder.INSTANCE, EnumHolder.INSTANCEpublic static Test getInstance() {return EnumHolder.INSTANCE.getTest();}}