6+3 种单例模式详解

前言

Java 版的单例模式是以前写的了,最近又补充了 Kotlin 的写法,所以一起发出来。这里的 6+3 说的就是 Java 的 6 种 + Kotlin 的 3 种。更多设计模式可以看我之前写的 AndroidNotes

一、介绍

定义
确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

简单示例

public class Singleton {
    private static Singleton instance = new Singleton;
    private Singleton () {
    }
    public static Singleton getInstance() {
        return instance;
    }
}

上面就是一个单例模式的简单使用示例,可以看到确实是自行实例化的,并且使用的是私有构造函数,目的是为了其他地方不能通过构造函数来创建该类的实例,只能通过公共的 getInstance() 方法获取该类的实例。

二、Java 版

2.1 饿汉式(线程安全)

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

小结:在类加载的时候就初始化实例,虽然避免了多线程并发操作导致的线程安全问题,但是会造成内存的浪费,因为还没有使用这个对象就把它加载到内存中了。

2.2 懒汉式(线程不安全)

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

小结:只有第一次用到的时候才初始化实例,解决了饿汉式造成内存浪费的问题,但是多线程的时候是不安全的。例如有线程 A 与线程 B 同时执行,这时候就有可能 2 个线程都同时执行到 if (instance == null),这样就创建了 2 个实例了,所以这种方式只适用于单线程。
详细的多线程并发可以看我之前写的 带你通俗易懂的理解——线程、多线程与线程池

2.3 懒汉式(线程安全)

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

小结:在 getInstance 方法上加了同步锁,这样有多个线程的时候会等前面的线程执行完了再执行当前线程,可以解决第二种懒汉式的线程安全问题。

2.4 双重校验锁(线程安全)

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
    }

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

小结:可以看到加了双重 if (instance == null) 的判断,并且同步锁放到了方法内部,新增的第一个判空可以避免每个线程过来都去执行同步锁,可以解决同步锁造成的效率低的问题。

但是,instance = new Singleton(); 并不是一个原子操作,这一行代码可以分成 3 个步骤:

  1. 给 instance 分配内存
  2. 初始化 instance,即执行 new Singleton();
  3. 将 instance 对象指向分配的内存空间

而且由于 JVM 具有指令重排的特性,也就是说无法保证上面的 3 个步骤是按 1>2>3 执行的,有可能是 1>3>2。例如线程 A 执行完第 1 步与第 3 步,而没有执行第 2 步,显然 instance 是不为空的,这个时候线程 B 刚好执行到 if (instance == null) ,发现不为空就直接返回 instance,但是由于一直没有执行到第 2 步,所以 instance 虽然不为空,但是是没有初始化完成的,所以调用一个没有初始化完成的实例肯定是有问题的。

所以代码中使用了 volatile 关键字,因为它可以解决指令重排的问题,但是只能在 JDK 1.5 之后生效。而且使用 volatile 关键字也会影响一些性能问题。

2.5 静态内部类(线程安全)

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

    private Singleton() {
    }

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

小结:这种方式在 Singleton 类加载的时候并没有初始化实例,而是第一次调用 getInstance() 的时候才进行初始化,可以达到延迟加载对象的作用。并且 JVM 能确保 INSTANCE 只被实例化一次。也就是这种方式可以实现双重校验锁一样的效果,而且解决了使用 volatile 关键字只能在 JDK 1.5 之后生效和影响性能的问题。但是这种方式用的人还是比较少的。

2.6 枚举(线程安全)

public enum Singleton {
    INSTANCE;

    public void testMethod() {
    }
}

小结:可以说使用枚举的方式实现单例是目前最完美的方式,这种方式可以防止序列化与反射造成的创建多个实例的问题,而前面的 5 种方式默认情况是无法解决这个问题的。可能使用枚举的唯一缺点是可读性不高。
关于序列化与反射造成的创建多个实例的问题可以看看这篇文章 为什么要用枚举实现单例模式(避免反射、序列化问题)

三、Kotlin 版

3.1 懒汉式(线程安全)

看下 官方文档 的写法:

object Singleton

你没看错,一行代码就搞定!

那么他属于 Java 中的哪一种呢?
看下官方文档怎么说的:

Object declaration’s initialization is thread-safe and done at first access.

即初始化是线程安全的,并且第一次用到的时候才初始化。也就是相当于 Java 版的第(3)、(4)、(5),不仅是懒汉式还是线程安全的。

那么内部原理是怎样的呢?
通过 Android Studio 转成 Java 代码看看:

public final class Singleton {
   public static final Singleton INSTANCE;

   private Singleton() {
   }

   static {
      Singleton var0 = new Singleton();
      INSTANCE = var0;
   }
}

可以看到它确实是一个单例模式,这里是通过静态代码块来初始化实例的。

那么静态代码块是什么时候执行的呢?
我们知道类加载过程分为加载、验证、准备、解析、初始化 5 个阶段,而静态代码块就是在初始化这个阶段执行的,JVM 中规定了以下几种情况会触发类的初始化:

  • 虚拟机启动时,会初始化包含 main 方法的主类。
  • 通过 new 指令创建对象实例时。
  • 访问类中的静态方法时。
  • 访问类中的静态字段时。
  • 对类进行反射调用时。

从上面转换的 Java 代码可知,当我们使用单例的时候,是通过 Singleton.INSTANCE 获取实例的,所以是通过访问类中的静态字段触发了类的初始化,也就是在这个时候执行了静态代码块。而且类的加载过程本身就是线程安全的,所以上面的单例不仅是懒汉式还是线程安全的

3.2 枚举(线程安全)

enum class Singleton {
    INSTANCE;
}

与 Java 版的第(6)种一样,可以防止序列化与反射造成的创建多个实例的问题。

3.3 带参数

可以看到,前面两种都无法像 Java 那样通过静态方法 getInstance() 传一个参数给单例:

public static Singleton getInstance(Context context) {}

那么我们可以模仿 官方的 demo 写一个:

class Singleton private constructor(context: Context) {

    companion object {
        @Volatile
        private var instance: Singleton? = null

        fun getInstance(context: Context) =
                instance ?: synchronized(this) {
                    instance ?: Singleton(context).also { instance = it }
                }
    }
}

实际就是将 Java 版中的第(4)种 “双重校验锁” 转换成 Kotlin 的写法。

四、优缺点

优点

  • 由于单例模式在内存中只有一个实例,对于需要频繁实例化然后销毁的对象可以减少内存开销。
  • 由于单例只有一个实例,对于创建比较耗资源的对象可以减少系统的性能开销。
  • 可以避免对资源的多重占用。
  • 可以在系统设置全局的访问点,优化和共享资源访问。

缺点

  • 单例模式一般没有接口,所以扩展困难,需要扩展只能修改原有的代码。
  • 单例模式与单一职责原则有冲突。

五、使用场景

  • 全局只需要一个实例的对象。
  • 需要频繁实例化然后销毁的对象。
  • 创建比较耗资源的对象,例如访问 IO 和数据库等资源。

六、如何选择?

  • Java 版:以上 6 种方式各有利弊(线程安全问题、性能问题、代码复杂度与可读性问题),所以需要根据自己的项目选择合适的方式。一般建议使用第三种线程安全的懒汉式(例如 Android 系统源码中的 LocalBroadcastManager 就是使用该种方式),如果涉及到序列化与反射则可以使用第六种枚举的方式。
  • Kotlin 版:一般情况下用第一种,如果涉及到序列化与反射则可以使用第二种枚举的方式,如果需要传参数则用第三种。

关于我

我是 wildmaCSDN 认证博客专家简书程序员优秀作者,擅长屏幕适配
如果文章对你有帮助,点个赞就是对我最大的认可!

wildma_ CSDN认证博客专家 屏幕适配 主流框架源码分析 Android
我是 wildma,CSDN 认证博客专家,简书程序员优秀作者,擅长屏幕适配。Github:https://github.com/wildma
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页