五种单例模式的Java与kotlin语言对比

最新推荐文章于 2024-08-08 09:23:20 发布

weixin_34304013

最新推荐文章于 2024-08-08 09:23:20 发布

阅读量160

点赞数

文章标签：移动开发 java

原文链接：https://juejin.im/post/5aeb2f276fb9a07aaf351014

版权

1、饿汉式

java方式

/**
 * Description:饿汉式单例
 */
public class BaseSingleton {

    private BaseSingleton(){}

    private static final BaseSingleton INSTANCE = new BaseSingleton();

    public static BaseSingleton getInstance() {
        return INSTANCE;
    }
}
复制代码

kotlin方式

/**
 * Description:饿汉式单例
 * 在kotlin中饿汉式单例只需要一个object修饰即可
 */

object BaseSingleton {

}
复制代码

懒汉式

java 方式

/**
 * Description:懒汉式单例，最常用的一种，非线程安全
 */
public class LazyLoadSingleton {

    private LazyLoadSingleton() {

    }

    private static LazyLoadSingleton INSTANCE;

    public static LazyLoadSingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazyLoadSingleton();
        }
        return INSTANCE;
    }
}
复制代码

kotlin 方式

/**
 * Description:懒汉式单例
 */

class LazyLoadSingleton private constructor() {

    /**
     * companion object相当于Java中的 public static 类似于静态代码块
     */
    companion object {

        //LazyThreadSafetyMode.NONE线程非安全  ——  对比与双重检测模式 LazyThreadSafetyMode.SYNCHRONIZED
        val INSTANCE by lazy(LazyThreadSafetyMode.NONE) {
            LazyLoadSingleton();
        }
    }
}
复制代码

同步加锁

java 方式

/**
 * Description:同步锁式单例
 * 优点：线程安全
 * 缺点：每次获取实例都会加锁
 */
public class LazySynchronizedSingleton {
    private LazySynchronizedSingleton() {

    }

    private static LazySynchronizedSingleton INSTANCE;

    public static synchronized LazySynchronizedSingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySynchronizedSingleton();
        }
        return INSTANCE;
    }
}
复制代码

kotlin 方式

/**
 * Description: 同步锁式单例
 * 优点：线程安全
 * 缺点：每次获取实例都会加锁
 */

class LazySynchronizedSingleton private constructor() {
    /**
     * companion object相当于Java中的 public static 类似于静态代码块
     */
    companion object {
        //kotlin中变量后面有？表示该变量可以为null
        private var INSTANCE : LazySynchronizedSingleton? = null

        /**
         * 在kotlin中通过注解方式加锁
         * !!表示非空判断
         */
        @Synchronized
        fun getInstance(): LazySynchronizedSingleton {
            if (INSTANCE == null) {
                INSTANCE = LazySynchronizedSingleton()
            }
            return INSTANCE!!
        }
    }
}
复制代码

双重检测式

java 方式

/**
 * Description:双重检测式单例
 * 优点：线程安全，不会重复加锁
 * 缺点：写法稍微复杂
 */
public class DoubleCheckSingleton {
    private DoubleCheckSingleton() {

    }

    private static volatile DoubleCheckSingleton INSTANCE;

    public static DoubleCheckSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DoubleCheckSingleton();
                }
            }
        }
        return INSTANCE;
    }
}
复制代码

kotlin方式

/**
 * Description:双重检测式单例
 * 线程安全，不会重复加锁，代码简洁
 */
class DoubleCheckSingleton private constructor() {

    /**
     * companion object相当于Java中的 public static
     */
    companion object {
        val INSTANCE by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            DoubleCheckSingleton()
        }
    }
}
复制代码

内部类式

java 方式

/**
 * Description:内部类式单例
 * 优点：写法简单，代码少，既满足了懒加载又满足了线程安全
 */
public class InnerStaticSingleton {
    private InnerStaticSingleton() {

    }

    private static class Holder{
        private static InnerStaticSingleton INSTANCE = new InnerStaticSingleton();
    }

    public static InnerStaticSingleton getInstance() {
        return Holder.INSTANCE;
    }
}
复制代码

kotlin 方式

/**
 * Description:内部类式单例
 * 优点：代码少，线程安全
 */
class InnerStaticSingleton private constructor() {

    /**
     * 内部类
     */
    private object Holder {
        val INSTANCE = InnerStaticSingleton()
    }

    companion object {
        fun getInstance() = Holder.INSTANCE
    }
}
复制代码