单例模式

单例模式是一个很常见的设计模式，尤其是在 Java 中应用非常广泛。单例模式的定义是保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Java 中的单例模式

Java 中存在多种单例模式的实现方案，最经典的包括：

• 
  
• 
  

  懒汉式

  
  
  
• 
  

  饿汉式

  
  
  
• 
  

  双重校验锁

  
  
  

饿汉式 / 静态单例

Java 中懒汉式单例如其名一样，“饿” 体现在不管单例对象是否存在，都直接进行初始化：

public final class SingleManager {

    @NotNull

    public static final SingleManager INSTANCE = new SingleManager();


    private SingleManager() {}


    public static SingleManager getInstance() {

        return INSTANCE;

    }

}

实际上，这也是静态单例。

懒汉式 / 延迟初始化

Java 中的懒汉式核心特点在于“懒” ，它不像饿汉式，无论 INSTANCE 是否已经存在值，都进行初始化；而是在调用 get 方法时，检查引用对象是否为空，如果为空再去初始化：

public final class SingleManager {

    public static SingleManager INSTANCE;


    private SingleManager() {}


    public static SingleManager getInstance() {

        if (INSTANCE == null) {

            INSTANCE = new SingleManager();

        } 

        return INSTANCE;

    }

}

双重校验锁

public final class SingleManager {

    // volatile 防止指令重排，确保原子操作的顺序性

    public volatile static SingleManager INSTANCE;


    private SingleManager() {}


    public static SingleManager getInstance() {

        // 第一次判空，减少进入同步锁的次数，提高效率

        if (INSTANCE == null) {

            // 确保同步

            synchronized (SingleManager.class) {

                // 确保加锁后，引用仍是空的

                if (INSTANCE == null) {

                    INSTANCE = new SingleManager();

                }

            }

        }

        return INSTANCE;

    }

}

Kotlin 中的单例模式

object 关键字

Kotlin 提供了比 Java 更方便的语法糖 object 关键字，能够更方便地实现单例模式：

object SingleManager {

    fun main() {}

}

使用：

// used in kotlin

SingleManager.main()

// used in java

SingleManager.Companion.main();

如果要在 Java 中的使用方式与 Kotlin 使用方式一致，可以在方法上添加 @JvmStatic 注解：

object SingleManager {

    @JvmStatic

    fun main() {}

}

// used in java

SingleManager.main();

object 关键字实现的单例，编译为 Java 字节码的实现是：

public final class SingleManager {

   @NotNull

   public static final SingleManager INSTANCE;


   public final void main() {

   }


   private SingleManager() {

   }


   static {

      SingleManager var0 = new SingleManager();

      INSTANCE = var0;

   }

}

这是一种标准的 Java 静态单例实现。

Kotlin 懒汉式

在一些特殊的情况，例如你的单例对象要保存一些不适合放在静态类中的引用，那么使用 object 就不是合适的方案了，例如，Android 中的上下文 Context 、View 都不适合在静态类中进行引用，IDE 也会提醒你这样会造成内存泄漏：

一种好的解决方案是在 Kotlin 中使用懒汉式的写法：

class SingleManager {

    companion object {

        private var instance: SingleManager? = null


        fun getInstance(): SingleManager {

            if (instance == null) {

                instance = SingleManager()

            }

            return instance!!

        }

    }


    var view: View? = null

}

但是这样仍然会提醒你不要引用：

但如果引用的对象是你自定义的 View ：

class BaseView @JvmOverloads constructor(

    context: Context, attrs: AttributeSet? = null

) : FrameLayout(context, attrs)

在 kotlin 中懒汉式是不会提示你的：

可以看出，使用 object 关键字，仍然会飘黄，提醒你可能存在内存泄漏。

本质上来说，没有提示实际上也是存在内存泄漏的隐患的。 虽然可以骗过 IDE 但不应该欺骗自己。

写在最后

Kotlin 作为一门更新的 JVM 语言，它提供了很多语法糖突破了 Java 的一些固定写法，有些设计模式已经不再适合新的语言(例如 Builder 模式在 Kotlin 中很少会出现了)。虽然新语言简化了代码的复杂度、简化了写法，但不能简化知识点，例如，使用 Kotlin 需要一个线程安全的单例，仍然可以使用双重校验锁的写法。本质上还是要搞清楚底层逻辑。