Kotlin Singleton 单例模式

最新推荐文章于 2023-03-23 22:24:11 发布
最新推荐文章于 2023-03-23 22:24:11 发布
阅读量718 收藏 2
点赞数
分类专栏： Kotlin 文章标签： kotlin singleton 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/louisgeek/article/details/114712874
版权

1 饿汉式

object Singleton {
    fun doSome1() {
        println("test")
    }
}

Kotlin 调用方式 Singleton.doSome1()

Java 调用方式 Singleton.INSTANCE.doSome1()

Android Studio 通过 Tools -> Kotlin -> Show Kotlin Bytecode 查看编译后的字节码，点 Decompile 转成反编译后的 Java 代码

//final 声明类不可变性
public final class Singleton {
   public static final Singleton INSTANCE;
   public final void doSome1() {
      String var1 = "test";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Singleton() {}
   static {
      Singleton var0 = new Singleton();
      INSTANCE = var0;
   }
}
  • 可以看出是饿汉式的 Java 单例模式
  • 线程安全
  • 无法进行传参

2 懒汉式

//2.1 线程不安全
class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
        @JvmStatic
        fun getInstance(): Singleton {
            if (instance == null) {
                instance = Singleton()
            }
            return instance as Singleton
        }
    }
    fun doSome1() {
        println("test")
    }
}

//2.1 反编译后的 Java 代码
public final class Singleton {
   private static Singleton instance;
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   public final void doSome1() {
      String var1 = "test";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Singleton() {
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   @JvmStatic
   @NotNull
   public static final Singleton getInstance() {
      return Companion.getInstance();
   }
   public static final class Companion {
      @JvmStatic
      @NotNull
      public final Singleton getInstance() {
         if (Singleton.instance == null) {
            Singleton.instance = new Singleton((DefaultConstructorMarker)null);
         }
         return Singleton.instance;
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

//2.2 线程安全，2.1 例子加上 @Synchronized 注解
class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
        @JvmStatic
        @Synchronized // 加了 @Synchronized 
        fun getInstance(): Singleton {
            if (instance == null) {
                instance = Singleton()
            }
            return instance as Singleton
        }
    }
    fun doSome1() {
        println("test")
    }
}

//2.2 反编译后的 Java 代码
public final class Singleton {
   private static Singleton instance;
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   public final void doSome1() {
      String var1 = "test";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Singleton() {
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
    //增加了 synchronized 关键字
   @JvmStatic
   @NotNull
   public static final synchronized Singleton getInstance() {
      return Companion.getInstance();
   }
   public static final class Companion {
       //增加了 synchronized 关键字
      @JvmStatic
      @NotNull
      public final synchronized Singleton getInstance() {
         if (Singleton.instance == null) {
            Singleton.instance = new Singleton((DefaultConstructorMarker)null);
         }
         return Singleton.instance;
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

//2.3 kotlin get() 特性写法 
//线程安全
class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
            get() {
                if (field == null) {
                    field = Singleton()
                }
                return field;
            }
        //Companion 里已经生成一个 private final Singleton getInstance 方法，所以改用 gainInstance 这个命名
        @JvmStatic
        @Synchronized
        fun gainInstance(): Singleton? {
            return instance
        }
    }
    fun doSome1() {
        println("test")
    }
}

//2.3 反编译后的 Java 代码
public final class Singleton {
   private static Singleton instance;
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   public final void doSome1() {
      String var1 = "test";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Singleton() {
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   @JvmStatic
   @Nullable
   public static final synchronized Singleton gainInstance() {
      return Companion.gainInstance();
   }
   public static final class Companion {
      private final Singleton getInstance() {
         if (Singleton.instance == null) {
            Singleton.instance = new Singleton((DefaultConstructorMarker)null);
         }
         return Singleton.instance;
      }
      private final void setInstance(Singleton var1) {
         Singleton.instance = var1;
      }
      @JvmStatic
      @Nullable
      public final synchronized Singleton gainInstance() {
         return ((Singleton.Companion)this).getInstance();
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}


//2.4 kotlin lazy 特性写法
//线程不安全
class Singleton private constructor(){
    companion object {
        @JvmStatic
        val instance by lazy(LazyThreadSafetyMode.NONE) {
            Singleton()
        }
    }
}

//2.4 反编译后的 Java 代码
public final class Singleton {
   @NotNull
   private static final Lazy instance$delegate;
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   private Singleton() {
   }
   static {
      instance$delegate = LazyKt.lazy(LazyThreadSafetyMode.NONE, (Function0)null.INSTANCE);
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   @NotNull
   public static final Singleton getInstance() {
      return Companion.getInstance();
   }
   public static final class Companion {
      /** @deprecated */
      // $FF: synthetic method
      @JvmStatic
      public static void instance$annotations() {
      }
      @NotNull
      public final Singleton getInstance() {
         Lazy var1 = Singleton.instance$delegate;
         Singleton.Companion var2 = Singleton.Companion;
         Object var3 = null;
         boolean var4 = false;
         return (Singleton)var1.getValue();
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

3 双重检查锁

//3.1  @Volatile 注解
class Singleton private constructor() {
    companion object {
        @Volatile
        private var instance: Singleton? = null
        @JvmStatic
        fun getInstance(): Singleton {
            if (instance == null) {
                synchronized(this) {
                    if (instance == null) {
                        instance = Singleton()
                    }
                }
            }
            return instance as Singleton
        }
    }
    fun doSome1() {
        println("test")
    }
}

//3.1 反编译后的 Java 代码
public final class Singleton {
   private static volatile Singleton instance;
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   public final void doSome1() {
      String var1 = "test";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Singleton() {
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   @JvmStatic
   @NotNull
   public static final Singleton getInstance() {
      return Companion.getInstance();
   }
   public static final class Companion {
      @JvmStatic
      @NotNull
      public final Singleton getInstance() {
         if (Singleton.instance == null) {
            boolean var1 = false;
            boolean var2 = false;
            synchronized(this) {
               int var3 = false;
               if (Singleton.instance == null) {
                  Singleton.instance = new Singleton((DefaultConstructorMarker)null);
               }
               Unit var5 = Unit.INSTANCE;
            }
         }
         return Singleton.instance;
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

//3.2 kotlin lazy 特性写法
class Singleton private constructor() {
    companion object {
        @JvmStatic
        val instance by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
            Singleton()
        }
    }
}

//3.2 反编译后的 Java 代码
public final class Singleton {
   @NotNull
   private static final Lazy instance$delegate;
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   private Singleton() {
   }
   static {
      instance$delegate = LazyKt.lazy(LazyThreadSafetyMode.SYNCHRONIZED, (Function0)null.INSTANCE);
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   @NotNull
   public static final Singleton getInstance() {
      return Companion.getInstance();
   }
   public static final class Companion {
      /** @deprecated */
      // $FF: synthetic method
      @JvmStatic
      public static void instance$annotations() {
      }
      @NotNull
      public final Singleton getInstance() {
         Lazy var1 = Singleton.instance$delegate;
         Singleton.Companion var2 = Singleton.Companion;
         Object var3 = null;
         boolean var4 = false;
         return (Singleton)var1.getValue();
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

4 object 对象声明 和 companion object 伴生对象

class Singleton private constructor() {
    //伴生对象
    companion object {
        @JvmStatic //方便 java 调用
        fun getInstance(): Singleton {
            return SingletonInstanceHolder.instance
        }
    }
    //对象声明
    private object SingletonInstanceHolder {
        val instance = Singleton()
    }
    fun doSome1() {
 		println("test")
    }
}

//4 反编译后的 Java 代码
public final class Singleton {
   public static final Singleton.Companion Companion = new Singleton.Companion((DefaultConstructorMarker)null);
   public final void doSome1() {
      String var1 = "test";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Singleton() {
   }
   // $FF: synthetic method
   public Singleton(DefaultConstructorMarker $constructor_marker) {
      this();
   }
   @JvmStatic
   @NotNull
   public static final Singleton getInstance() {
      return Companion.getInstance();
   }
   private static final class SingletonInstanceHolder {
      @NotNull
      private static final Singleton instance;
      public static final Singleton.SingletonInstanceHolder INSTANCE;
      @NotNull
      public final Singleton getInstance() {
         return instance;
      }
      static {
         Singleton.SingletonInstanceHolder var0 = new Singleton.SingletonInstanceHolder();
         INSTANCE = var0;
         instance = new Singleton((DefaultConstructorMarker)null);
      }
   }
   public static final class Companion {
      @JvmStatic
      @NotNull
      public final Singleton getInstance() {
         return Singleton.SingletonInstanceHolder.INSTANCE.getInstance();
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
louisgeek
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Kotlin中单例模式和Java的对比浅析
08-27
单例模式是一种常用的设计模式，在 Java 和 Kotlin 中都有多种实现方式。下面我们将对比 Kotlin 中单例模式和 Java 中单例模式的实现方式。 一、懒人写法（恶汉式） 在 Java 中，懒人写法是最简单的单例模式实现...
Android-用Kotlin实现设计模式代码
08-13
1. **单例模式(Singleton)**：在Android中，单例模式常用于创建全局唯一实例，例如网络请求管理器、数据库访问对象等。Kotlin的`object`关键字可以简化单例的实现，避免线程安全问题。 ```kotlin object Singleton ...
Kotlin~Singleton单例模式
最新发布
Hynson的学习笔记
03-23 651
保证一个类只有一个实例，并为该实例提供一个全局唯一的访问节点。
Kotlin关键字
一只程序菜鸡的博客
03-27 325
let扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，let函数的是一个不错的选择；let函数另一个作用就是可以避免写一些判断null的操作。 ...
kotlin_01：kotlin中的单例写法
weixin_44467766的博客
03-11 2217
**前言：**入职半年，从学生变成了打工狗。从java变成了android，无所谓了，干一行爱一行吧。在此记录一下工作中的学习的知识吧。（单纯的知识，跟公司任何东西无关） 在java中大家都知道，是直接有静态的static关键字来修饰类和变量的，但是在kotlin ...
Kotlin单例方法
赵航的博客
07-01 9534
这篇文章简单介绍下kotlin中单例的实现方法。 1：饿汉式 java的实现很简单，我们直接上代码： public class SingleTon1 { private static SingleTon1 singleTon1 = new SingleTon1(); private SingleTon1() { } public static SingleTon1 getInstance() { return singleTon1; } } 那k
Kotlin是如何做的 之单例
haoyifen的专栏
02-16 3575
Kotlin是如何实现的之 单例
Kotlin基本
02-21
单例模式可以使用object关键字实现。例如： ```kotlin class Person(val name: String) object Singleton { fun getInstance() = "Singleton Instance" } ``` 5. **扩展函数与属性**：Kotlin允许向现有的类...
建筑图案Kotlin
02-22
3. **单例模式（Singleton Pattern）**：Kotlin提供了一种内置的方式来创建单例对象，只需在类名前加上`object`关键字即可。这种方式确保了类在整个应用生命周期内只有一个实例，常用于配置管理、全局缓存等场景。 ...
Kotlin之单例模式
七夜聖君的博客
12-26 706
kotlin之单例模式笔记
【自用】 Kotlin Singleton ......
weixin_34227447的博客
05-29 91
2019独角兽企业重金招聘Python工程师标准>>> ...
Kotlin下的5种单例模式
相思雨的博客
08-25 2370
一、饿汉式实现   //Java实现 public class SingletonDemo { private static SingletonDemo instance=new SingletonDemo(); private SingletonDemo(){ } public static SingletonDemo getInstance(){ ...
Kotlin的5种单例写法和java对比
一现灵光
06-14 832
​​​​​​主要单例模式实现如下： 饿汉式 懒汉式 线程安全的懒汉式 双重校验锁式 静态内部类式 一，饿汉式实现 （1）java恶汉式 public class Singleton{ public static final Singleton instance = new Singleton(); public static Singleton getInstance() { return instance; } } （2）Kotlin饿汉式 /
kotlin学习之单例
Iturbo
06-19 4552
关于单例模式的介绍可以看这篇文章： http://cantellow.iteye.com/blog/838473 就拿第一种做例子，懒汉式 public class SingleTon { private static SingleTon instance; private SingleTon (){} public static SingleTon g
Kotlin实现常用的五种单例模式
weixin_33857230的博客
10-17 410
废话不多说，直接上代码，记录一下，方便以后使用 class ImageClassifyUtil private constructor(){ /** * 饿汉 */ companion object { val instance = ImageClassifyUtil() } /** * 懒汉 */ ...
kotlin之单例模式
wangxp423的博客
06-20 1334
一，Java单例模式回顾 Java设计模式汇总(全)–回顾 Java单例设计模式–回顾 二，kotlin不带参数单例模式 class Singleton private constructor(){ private object Holder{ val singleton = Singleton() } companion object {...
@Scope 看这一篇就够了——Dagger2 （二）
热门推荐
薛瑄的博客
03-30 1万+
转载请标明出处：http://blog.csdn.net/xx326664162/article/details/67640509 文章出自：薛瑄的博客Dagger2 系列：Dagger2 入门详解（一）@Scope 看这一篇就够了——Dagger2 （二）网上关于@Scope的讲解，不是很详细，甚至有的是错误的。比如：Android：dagger2让你爱不释手-重点概念讲解、融合篇这篇文章网上引用
用kotlin实现单例模式，案例
02-16
单例模式是一种常用的设计模式，它保证一个类在应用程序中只有一个实例。在 Kotlin 中，可以通过 object 关键字来实现单例模式。下面是一个简单的示例： ```kotlin object MySingleton { init { println("Singleton initialized") } fun doSomething() { println("Singleton doing something") } } ``` 在上面的代码中，我们使用 object 关键字定义了一个名为 MySingleton 的单例对象。当该对象被创建时，init 块中的代码将被执行，这里我们只是打印一条消息。 MySingleton 对象还定义了一个名为 doSomething 的函数，它可以在应用程序的其他部分中调用。在此函数中，我们只是打印另一条消息。 使用单例模式的主要好处是，它可以确保一个类只有一个实例，并且在整个应用程序中都可以访问该实例。这可以避免重复的对象创建，并提高应用程序的性能。 为了在应用程序中使用 MySingleton 对象，只需要调用它的函数即可： ```kotlin MySingleton.doSomething() ``` 输出： ``` Singleton initialized Singleton doing something ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

louisgeek

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值