Kotlin Java单例模式

Java最简单单例

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

Kotlin最简单单例

object Singleton{
}

Java考虑懒加载用来节省开销

/**
 * Created by XueyueBai on 2017/7/18.
 * Description 线程不安全的懒加载方式
 */

public class LazyNotThreadSafe {
    private static LazyNotThreadSafe INSTANCE;

    public LazyNotThreadSafe() {
    }

    public static LazyNotThreadSafe getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazyNotThreadSafe();

        }
        return INSTANCE;
    }
}

Kotlin考虑懒加载用来节省开销

/**
 * Created by XueyueBai on 2017/7/18.
 * Description
 */
class LazyNotThreadSafe {
    companion object {
        val INSTANCE by lazy(LazyThreadSafetyMode.NONE) {
            LazyNotThreadSafe()
        }
        /***
         * 等价写法，java翻译写法
         */
        private var INSTANCE2: LazyNotThreadSafe? = null

        fun get(): LazyNotThreadSafe {
            if (INSTANCE2 == null) {
                INSTANCE2 = LazyNotThreadSafe()
            }
            return INSTANCE2!!
        }
    }

}

Java 使用了懒加载，但是线程是不安全的。所以继续改进，加锁控制下

/**
 * Created by XueyueBai on 2017/7/18.
 * Description 加个锁改进下，保证线程安全。不过多个线程可能会创建多个对象，这种单例不合适
 */

public class LazyThreadSafeSynchronized {
    private static LazyThreadSafeSynchronized INSTANCE;

    private LazyThreadSafeSynchronized() {
    }

    public static synchronized LazyThreadSafeSynchronized getInastance() {
        if (INSTANCE == null) {
            INSTANCE = new LazyThreadSafeSynchronized();
        }
        return INSTANCE;
    }
}

Kotlin 使用了懒加载，但是线程是不安全的。所以继续改进，加锁控制下

/**
 * Created by XueyueBai on 2017/7/18.
 * Description  加个锁改进下，保证线程安全。不过多个线程可能会创建多个对象，这种单例不合适
 */
class LazyThreadSafeSynchronized private constructor() {
    companion object {
        private var INSTANCE: LazyThreadSafeSynchronized? = null
        @Synchronized
        fun getInstance(): LazyThreadSafeSynchronized {
            if (INSTANCE == null) {
                INSTANCE = LazyThreadSafeSynchronized()
            }
            return INSTANCE!!
        }
    }
}

Java加锁控制后多线程情况下可能会创建多个单例，所以继续改进（进行两次检查）

/**
 * Created by XueyueBai on 2017/7/18.
 * Description   使用 volatile 关键字改进下
 */

public class LazyThreadSafeDoubleCheck {
    private static volatile LazyThreadSafeDoubleCheck INSTANCE;

    private LazyThreadSafeDoubleCheck() {
    }

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

Kotlin加锁控制后多线程情况下可能会创建多个单例，所以继续改进（进行两次检查）

/**
 * Created by XueyueBai on 2017/7/18.
 * Description
 */
class LazyThreadSafeDoubleCheck private constructor() {
    companion object {
        val insttance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            LazyThreadSafeDoubleCheck()
        }
        /***
         * 等价写法，java翻译写法
         */
        private @Volatile var Instance2: LazyThreadSafeDoubleCheck? = null
        fun getInstance(): LazyThreadSafeDoubleCheck {
            if (Instance2 == null) {
                synchronized(this) {
                    if (Instance2 == null) {
                        Instance2 = LazyThreadSafeDoubleCheck()
                    }
                }
            }
            return Instance2!!
        }
    }
}

以上集中最合适的是进行两次检查的方式实现单例模式，不过java书写挺繁琐。有大神提供了一种静态内部类的实现方式

/**
 * Created by XueyueBai on 2017/7/18.
 * Description  单例静态内部类写法，最为简单。满足多线程中的单例，以及开销合理
 */

public class LazyThreadSafeStaticInnerClass {
    private static class Holder {
        private static LazyThreadSafeStaticInnerObject INSTANCE = new LazyThreadSafeStaticInnerObject();
    }

    public LazyThreadSafeStaticInnerClass() {
    }

    public static LazyThreadSafeStaticInnerObject getIntance() {
        return Holder.INSTANCE;
    }
}

kotlin 的静态内部类实现（其实java实现方式翻译成kotlin）

/**
 * Created by XueyueBai on 2017/7/18.
 * Description
 */
class LazyThreadSafeStaticInnerObject private constructor() {
    companion object {
        fun getInstance() = Holder.instance
    }
    private object Holder {
        val instance = LazyThreadSafeStaticInnerObject()

    }
}

 

转载于:https://my.oschina.net/xuehouyese/blog/1456644