Kotlin和Java 单例模式

最新推荐文章于 2024-10-31 17:33:26 发布
最新推荐文章于 2024-10-31 17:33:26 发布
阅读量2.2k 收藏 13
点赞数 23
文章标签： 单例模式 java kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdsjlzx/article/details/136039088
版权

Java 和Kotlin的单例模式其实很像，只是Kotlin一部分单例可以用对象类和委托lazy来实现

Java

/**
 * 懒汉式，线程不安全
 */
class Singleton {
    private static Singleton instance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

/**
 * 懒汉式，线程安全
 */
class Singleton1 {
    private static Singleton1 instance;
    private Singleton1() {
    }
    public static synchronized Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }
}

/**
 * 饿汉式
 */
class Singleton2 {
    private static Singleton2 instance = new Singleton2();
    private Singleton2() {
    }
    public static Singleton2 getInstance() {
        return instance;
    }
}

/**
 * 双检锁/双重校验锁（DCL，即 double-checked locking）
 */
class Singleton3 {
    private volatile static Singleton3 singleton;
    private Singleton3() {
    }
    public static Singleton3 getSingleton() {
        if (singleton == null) {
            synchronized (Singleton3.class) {
                if (singleton == null) {
                    singleton = new Singleton3();
                }
            }
        }
        return singleton;
    }
}

/**
 * 登记式/静态内部类
 */
class Singleton4 {
    private static class SingletonHolder {
        private static final Singleton4 INSTANCE = new Singleton4();
    }
    private Singleton4() {
    }
    public static final Singleton4 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

/**
 * 枚举
 */
enum Singleton5 {
    INSTANCE2;
    public void whateverMethod() {
        System.out.println("....");
    }
}

Kotlin

/**
 * 懒汉式，线程不安全，仿Java
 */
internal class Singleton6 private constructor() {
    companion object {
        private var instance: Singleton6? = null

        fun getInstance(): Singleton6 {
            if (instance == null) {
                instance = Singleton6()
            }
            return instance!!
        }
    }
}

/**
 * 懒汉式，线程不安全
 */
internal class Singleton7 private constructor() {
    companion object {
        var instance: Singleton7? = null
            get() {
                if (field == null) {
                    field = Singleton7()
                }
                return field
            }

    }
}

/**
 * 懒汉式，线程安全
 */
internal class Singleton8 private constructor() {
    companion object {
        @get:Synchronized
        var instance: Singleton8? = null
            get() {
                if (field == null) {
                    field = Singleton8()
                }
                return field
            }
    }
}

/**
 *饿汉式
 */
internal object Singleton9 {
    fun whateverMethod() {
        println("....")
    }
}

/**
 *饿汉式，仿Java
 */
internal class Singleton10 private constructor() {
    companion object {
        val instance = Singleton10()
    }
}

/**
 * 双检锁/双重校验锁（DCL，即 double-checked locking）
 */
internal class Singleton12 private constructor() {
    companion object {
        val instance: Singleton12 by lazy {
            Singleton12()
        }
    }
}

/**
 * 双检锁/双重校验锁（DCL，即 double-checked locking）,仿Java
 */
internal class Singleton11 private constructor() {
    companion object {
        @Volatile
        var instance: Singleton11? = null
            get() {
                if (field == null) {
                    synchronized(Singleton11::class) {
                        if (field == null) {
                            field = Singleton11()
                        }
                    }
                }
                return field
            }
    }
}

/**
 * 登记式/静态内部类
 */
internal class Singleton13 {
    private object SingletonHolder {
        val INSTANCE = Singleton13()
    }

    companion object {
        val instance: Singleton13
            get() = SingletonHolder.INSTANCE
    }
}

/**
 * 枚举
 */
internal enum class Singleton14 {
    INSTANCE;

    fun whateverMethod() {
        println("....")
    }
}

Kotlin的5种单例模式

前言

最近在学习Kotlin这门语言，在项目开发中，运用到了单例模式。因为其表达方式与Java是不同的。所以对不同单例模式的实现进行了分别探讨。主要单例模式实现如下：

  • 饿汉式
  • 懒汉式
  • 线程安全的懒汉式
  • 双重校验锁式
  • 静态内部类式

PS:该篇文章不讨论单例模式的运用场景与各种模式下的单例模式的优缺点。只讨论在Java下不同单例模式下的对应Kotlin实现。

一、饿汉式实现

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance=new SingletonDemo();
    private SingletonDemo(){
 
    }
    public static SingletonDemo getInstance(){
        return instance;
    }
}
//Kotlin实现
object SingletonDemo


这里很多小伙伴就吃了一惊。我靠，一个object 关键字就完成相同的功能？一行代码？

Kotlin的对象声明

学习了Kotlin的小伙伴肯定知道,在Kotlin中类没有静态方法。如果你需要写一个可以无需用一个类的实例来调用，但需要访问类内部的函数（例如，工厂方法,单例等），你可以把该类声明为一个对象。该对象与其他语言的静态成员是类似的。如果想了解Kotlin对象声明的更多内容，可以去看看之前的文章。

到这里，如果还是有很多小伙伴不是很相信一行代码就能解决这个功能，我们可以通过一下方式查看Kotlin的字节码。

查看Kotlin对应字节码


 

我们进入我们的Android Studio(我的Android Studio 3.0,如果你的编译器版本过低，请自动升级) 选择Tools工具栏，选择"Kotlin",选择“Show Kotlin Bytecode"

选择过后就会进入到下方界面：

点击"Decompile" 根据字节码得到以下代码：

public final class SingletonDemo {
   public static final SingletonDemo INSTANCE;
   private SingletonDemo(){}
   static {
      SingletonDemo var0 = new SingletonDemo();
      INSTANCE = var0;
   }
}


通过以上代码，我们了解事实就是这个样子的，使用Kotlin"object"进行对象声明与我们的饿汉式单例的代码是相同的。

二、懒汉式

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}
//Kotlin实现
class SingletonDemo private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = SingletonDemo()
                }
                return field
            }
        fun get(): SingletonDemo{
        //细心的小伙伴肯定发现了，这里不用getInstance作为为方法名，是因为在伴生对象声明时，内部已有getInstance方法，所以只能取其他名字
         return instance!!
        }
    }
}


上述代码中，我们可以发现在Kotlin实现中，我们让其主构造函数私有化并自定义了其属性访问器，其余内容大同小异。

三、线程安全的懒汉式

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static synchronized SingletonDemo getInstance(){//使用同步锁
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}
//Kotlin实现
class SingletonDemo private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = SingletonDemo()
                }
                return field
            }
        @Synchronized
        fun get(): SingletonDemo{
            return instance!!
        }
    }
 
}


大家都知道在使用懒汉式会出现线程安全的问题，需要使用使用同步锁，在Kotlin中，如果你需要将方法声明为同步，需要添加@Synchronized注解。

四、双重校验锁式（Double Check)

//Java实现
public class SingletonDemo {
    private volatile static SingletonDemo instance;
    private SingletonDemo(){} 
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}
//kotlin实现
class SingletonDemo private constructor() {
    companion object {
        val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
        SingletonDemo() }
    }
}


小伙伴们惊不惊喜，感不感动啊。我们居然几行代码就实现了多行的Java代码。其中我们运用到了Kotlin的延迟属性 Lazy。

Lazy是接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果，后续调用 get() 只是返回记录的结果。

这里还有有两个额外的知识点。

  • 高阶函数，高阶函数是将函数用作参数或返回值的函数。大家还是看这个 ---​ ​高阶函数​​
  • ​委托属性​​

五、静态内部类式

//Java实现
public class SingletonDemo {
    private static class SingletonHolder{
        private static SingletonDemo instance=new SingletonDemo();
    }
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        return SingletonHolder.instance;
    }
}
//kotlin实现
class SingletonDemo private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }
 
    private object SingletonHolder {
        val holder= SingletonDemo()
    }
}

静态内部类的实现方式，也没有什么好说的。Kotlin与Java实现基本雷同。

六、补充

那么如果小伙伴问，如何在Kotlin版的Double Check，给单例添加一个属性，这里给大家提供了一个实现的方式：

class SingletonDemo private constructor(private val property: Int) {
//这里参数可以根据实际需求发生改变
    companion object {
        @Volatile private var instance: SingletonDemo? = null
        fun getInstance(property: Int) =
                instance ?: synchronized(this) {
                    instance ?: SingletonDemo(property).also { instance = it }
                }
    }
}


其中关于​​?:​​​操作符，如果 ​​?:​​ 左侧表达式非空，就返回其左侧表达式，否则返回右侧表达式。 请注意，当且仅当左侧为空时，才会对右侧表达式求值。

一叶飘舟
关注
每日一问：Java与Kotlin的单例实现
Android、HTML、CSS、JS、JAVA、Kotlin、PHP等技术
06-18 374
Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问（这里不考虑反射）。这种写法lazy loading很明显，但是是在多线程不能安全。为了确保线程安全，可以在getInstance方法上加同步锁 这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。 4.静态内部类 这种方式也利用了classloder的机制
kotlin 入门到精通 单例模式(六)
2401_84149785的博客
04-18 724
static {说到延迟加载就直接跳到线程安全且性能较好的doubleCheck吧，若是用java实现会用2层check，第一层判断减轻锁的负担直接判断是否创建过，第二层判断加锁保证线程安全,最后用volatile禁止重排序防止编译器优化导致的线程安全问题。在kotlin里面也无需这么复杂，直接使用by lazy代理即可实现复制代码这个要归功于委托和lazy.kt复制代码可以看到上文，把val doubleCheckSin委托给了lazy, get时返回的是lazy.kt的value。
java和kotlin实现单例模式
安妍妍的博客
08-24 565
定义及使用场景 定义：确保某个类只有一个实例，而且自行实例化提供给外部使用。 使用场景：某个类型的对象实例应该有且只有一个，或者避免创建多个对象实例消耗过多的资源时。如：网络库，访问IO，数据库时要考虑单例模式。 单例模式的实现方式 1.饿汉式 优点：简单，线程安全 缺点：在类加载的时候就创建，不管需不需要都会创建，不能传参 适用场景：单例的创建开销小 java： public class HungrySingleton { //在类加载的时候创建单例 private static Hung
Kotlin 学习之单例模式(java, kotlin)
嘻哈包袱铺 专栏
07-02 423
前言java 常见的单例模式有三种:懒汉: getInstance的时候实例化;饿汉: 引用AA类的时候实例化, 例如 AA.fun() 或者 AA.getInstance();静态内部类: getInstance的时候实例化, 写法比懒汉要简单;个人理解: 如果没有除了getInstance 方法之外的 public static fun 的话, 以上三种单例模式在加载时间上基本是没有差别的. ...
Kotlin与Java的几种单例模式
weixin_45828419的博客
10-22 1126
一、饿汉式(线程安全，调用效率高，但是不能延时加载) JAVA例子： public class Test { private static Test test = new Test(); private Test() {} public static Test getInstance() { return test; } // 忽略方法printTest()，仅用来输出 public void printTest() { Sys
使用kotlin 实现Java 单例
weixin_34344403的博客
06-09 246
2019独角兽企业重金招聘Python工程师标准>>> ...
Kotlin之单例模式
七夜聖君的博客
12-26 745
kotlin之单例模式笔记
Android 组件化架构概要，kotlin带参数的单例模式
m0_66264569的博客
02-18 827
3.自定义Gradle 我们在Project的根目录创建一个config.gradle来统筹我们的依赖和版本信息 里面比较关键的还是我们配置的 IS_BUILD_MODULE 变量，如果可以设置当为true的时候，Module可以单独运行，即Application，如果为false，那么我们就只能让Module作为Library来执行，至于其他的，都是一些普通的配置。 IS_BUILD_MODULE 这个开关还可以放在gradle.properties中，实际上我觉得放在gradle.properties
Kotlin五种单例模式详解：从饿汉到静态内部类
本文将详细介绍Kotlin中的五种单例模式实现，分别是饿汉式、懒汉式、线程安全的懒汉式、双重校验锁式以及静态内部类式。这些模式在Java中常见，但在Kotlin中，由于其语法特点，实现方式有所不同。 1. **饿汉式**: ...
Kotlin 与 Java 代码的互调、一些冲突、常见问题
张雨的博客
09-09 1075
java调用kotlin方法 //Main.java 调用kotlin方法 public class Main { public static void main(String[] args) { TestKt.echo("hello kotlin"); // 打印结果————kotlin中的方法，hello kotlin } } //Test.kt 其中的函数和变量都会编译成 “pulic static” 的方法和变量 fun echo(name: String) {.
Kotlin单例方法
赵航的博客
07-01 9715
这篇文章简单介绍下kotlin中单例的实现方法。 1：饿汉式 java的实现很简单，我们直接上代码： public class SingleTon1 { private static SingleTon1 singleTon1 = new SingleTon1(); private SingleTon1() { } public static SingleTon1 getInstance() { return singleTon1; } } 那k
Kotlin 与 Java 相互调用
William的博客
12-11 8147
目录一、Kotlin 调用 Java1. kotlin 关键字转义2. kotlin 可将数组传给 java 的可变数量参数3. kotlin 获取对象的 java 类二、Java 调用 Kotlin1. java 调用 kotlin 类的属性和方法2. java 调用 kotlin 的顶级属性和顶级函数3. java 调用生成指定类名的 kotlin 属性和函数4. java 调用 kotlin 的伴生对象的方法和静态方法5. java 调用 kotlin 单例类的方法6. java 调用 kotlin
Linux：线程安全的单例模式
最新发布
Au_ust的博客
10-31 313
设计模式听上去是个很高贵的名词，其实就是是一套 多数人知晓、被反复使用、经过分类编目的、代码设计经验的总结，简称：对于编程比较典的场景的解决方案。
C++基础三（构造函数，形参默认值，函数重载，单例模式，析构函数，内联函数，拷贝构造函数）
m0_69147706的博客
10-28 986
构造函数(初始化类成员变量)：1、属于类的成员函数之一2、构造函数没有返回类型3、构造函数的函数名必须与类名相同4、构造函数不允许手动调用(不能通过类对象调用)5、构造函数在类对象创建时会被自动调用6、如果没有显示声明构造函数，系统会生成一个默认的构造函数7、如果显示声明了构造函数，那么默认构造函数将不会在被创建8、构造函数不被设置为静态成员函数9、构造函数的函数首部之前或函数首部之后不能用const修饰。
java开发如何在单例模式下通过锁机制防止并发？
梦在硅谷的博客
10-31 428
单例模式的核心思想是限制类的实例化次数，确保一个类只有一个实例。需要控制资源的访问，例如数据库连接池。需要全局共享的配置或状态。需要避免重复创建对象的开销。在Java项目中，单例模式是一种重要的设计模式，确保了类的唯一性。在多线程环境下实现单例模式时，必须考虑并发问题。通过使用等锁机制，可以有效地防止并发问题。选择合适的单例模式实现方式和并发控制机制，可以提高系统的性能和稳定性。在实际开发中，建议根据具体需求和场景，选择最适合的实现方式。
unity3d——单例模式，加载单例模式类问题
2401_82978699的博客
10-28 531
类没有挂载在Unity编辑器中的任何一个GameObject上，并且没有被其他脚本直接引用，那么它的加载时机可能会变得不那么确定。GameDataMgr.Instance.xx GameDataMgr 类就被加载到程序内存中 也就是说 他会自动new 如何执行 private 中的构造函数。如果该单例模式没用挂载到任何地方 那么他会在什么时候加载到内存中呢？
DAO模式及单例模式
nice66660的博客
10-29 548
Data Access Object(数据存取对象)位于业务逻辑和持久化数据之间实现对持久化数据的访问注意： 在整个程序运行期间，有且仅有一个实例。若违背这一点，所设计的类就不是单例类单例模式懒汉模式饿汉模式概念在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例在类加载的时候，就完成初始化特点类加载速度快，但是运行时获取对象的速度较慢。——“时间换空间”类加载较慢，但获取对象速度快。——“空间换时间”延迟加载(lazy loa ding)具备不具备线程安全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值