我们先看单例模式的定义：单例模式在Java中是最简单的一种设计模式，一个类负责创建自身唯一的对象，该对象可以全局访问，且外部不需要实例化。
有些朋友刚刚从Java切到Kotlin，语法上有些不习惯，创建单例的时候不知道怎么写，下面我提供几种方法。
一、饿汉式
Java：
public class SingletonObject{
private static SingletonObject instance = new SingletonObject();
private SingleObject(){}
public static SingletonObject getInstance(){
return instance;
}
public void something(){
//do something
}
}
Kotlin:
object SingletonObject{
fun something(){
//do something
}
}
一行代码就可以实现，通过反编译成java语言不难发现写法上都是一样的
public final class SingletonObject {
@NotNull
public static final SingletonObject INSTANCE;
public final void something() {
}
private SingletonObject() {
}
static {
SingletonObject var0 = new SingletonObject();
INSTANCE = var0;
}
}
优点：最简单的一种方式，在类加载时就实例化，所以它是线程安全的，因为没有锁，不会影响访问效率。
缺点：在类加载时不管这个单例中的实例有没有用到都被实例化了，在未被使用时会浪费内存。
总结：类加载的原因虽然有很多，但单例类往往是因为调用了内部的静态函数，所以一般情况下这种写法也能做到懒加载。我个人非常推荐这种写法，而且既然语言官方支持，说明这是在内存和效率权衡下的最优方案。
二、懒汉式
Java：
public class SingletonObject {
private static SingletonObject instance;
private SingletonObject() {
}
public static SingletonObject getInstance() {
if (instance == null) {
instance = new SingletonObject();
}
return instance;
}
public void something() {
//do something
}
}
Kotlin：
class SingletonObject private constructor(){
fun something() {
//do something
}
companion object {
var instance: SingletonObject? = null
get() {
if (field == null) {
field = SingletonObject()
}
return field
}
}
}
优点：仅仅在使用时才会实例化这个单例，减少了内存占用。
缺点：线程不安全，并且Kotlin的空安全特性会让你用起来非常难受，Koltin中每次访问这个单例都要处理空安全。
总结：如果能确保没有多线程访问，这种方法未尝不可。
三、加锁懒汉式
总结了第二种方式的缺点，很容易想到可以在访问时加锁解决问题，加锁懒汉式应运而生。
Java：
public class SingletonObject {
private static SingletonObject instance;
private SingletonObject() {
}
public static synchronized SingletonObject getInstance() {
if (instance == null) {
instance = new SingletonObject();
}
return instance;
}
public void something() {
//do something
}
}
Koltin：
class SingletonObject private constructor() {
fun something() {
//do something
}
companion object {
var instance: SingletonObject? = null
@Synchronized get() {
if (field == null) {
field = SingletonObject()
}
return field
}
}
}
优点：仅仅在使用时才会实例化这个单例，减少了内存占用，同时兼顾线程安全。
缺点：每次访问这个单例都要同步锁（效率低）、Koltin中要处理空安全。
总结：如果获取实例的次数很少，这种方法未尝不可。
四、双检锁懒汉式
既然知道了前两种方案的缺点，那有没有完美方案呢？有，双检锁懒汉式就是
Java：
public class SingletonObject {
private static SingletonObject instance;
private SingletonObject() {
}
public static SingletonObject getInstance() {
if (instance == null) {
synchronized (SingletonObject.class) {
if (instance == null) {
instance = new SingletonObject();
}
}
}
return instance;
}
public void something() {
//do something
}
}
Kotlin：
class SingletonObject private constructor() {
fun something() {
//do something
}
companion object {
var instance: SingletonObject? = null
get() {
if (field == null) {
synchronized(SingletonObject::class.java) {
if (field == null) {
field = SingletonObject()
}
}
}
return field
}
}
}
优点：仅仅在使用时才会实例化这个单例，减少了内存占用，同时兼顾线程安全。
缺点：写法较繁琐、Koltin中要处理空安全。
总结：比较完美的方案，兼顾了效率和内存，如果在Kotlin中，那这不是最好的方案。
五、静态内部类
Java：
public class SingletonObject {
private static class LazyHolder{
private static SingletonObject instance = new SingletonObject();
}
private SingletonObject() {
}
public static SingletonObject getInstance() {
return LazyHolder.instance;
}
public void something() {
//do something
}
}
Koltin：
class SingletonObject private constructor() {
fun something() {
//do something
}
val instance: SingletonObject
get() = LazyHolder.singletonObject
private object LazyHolder {
val singletonObject = SingletonObject()
}
}
对于这种实现方式，其实Kotlin还有另一种写法，通过lazy委托，写起来要简洁不少
class SingletonObject private constructor() {
fun something() {
//do something
}
val instance: SingletonObject by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
SingletonObject()
}
}
优点：仅仅在使用时才会实例化这个单例，减少了内存占用，同时兼顾线程安全。
总结：算是第一种方法的补充版，通过可控类加载保证懒加载效果，没有明显的短板。不推荐的原因是会多写很多代码，Koltin调用时也不如第一种方式简单。
六、枚举
Java：
enum SingletonObject {
INSTANCE;
public void something() {
//do something
}
}
Kotlin：
enum class SingletonObject {
INSTANCE;
fun something() {
//do something
}
}
优点：简单、线程安全，通过枚举可以有效防止重复实例化，据说还能防止反射。
总结：比较冷门，没有明显短板。
