Kotlin教程笔记(57) - 改良设计模式 - 单例模式

简介: Kotlin教程笔记(57) - 改良设计模式 - 单例模式

本系列学习教程笔记属于详细讲解Kotlin语法的教程,需要快速学习Kotlin语法的小伙伴可以查看“简洁” 系列的教程

快速入门请阅读如下简洁教程:
Kotlin学习教程(一)
Kotlin学习教程(二)
Kotlin学习教程(三)
Kotlin学习教程(四)
Kotlin学习教程(五)
Kotlin学习教程(六)
Kotlin学习教程(七)
Kotlin学习教程(八)
Kotlin学习教程(九)
Kotlin学习教程(十)

Kotlin教程笔记(57) - 改良设计模式 - 单例模式

在Kotlin中,单例模式是一种常见且实用的设计模式,用于确保一个类只有一个实例,并提供全局访问点。本文将介绍几种常见的Kotlin单例实现方式,以及它们的原理和具体使用方法。

饿汉式单例

java实现

public class PlainOldSingleton {
    private static PlainOldSingleton INSTANCE = new PlainOldSingleton();

    private PlainOldSingleton(){
        System.out.println("PlainOldSingleton");
    }

    public static PlainOldSingleton getInstance(){
        return INSTANCE;
    }
}

kotlin实现

object PlainOldSingleton {

}

非线程安全的懒汉式单例

java实现

public class LazyNotThreadSafe {
    private static LazyNotThreadSafe INSTANCE;

    private LazyNotThreadSafe(){}

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

kotlin实现

class LazyNotThreadSafe {

    companion object{
        val instance by lazy(LazyThreadSafetyMode.NONE) {
            LazyNotThreadSafe()
        }

        //下面是另一种等价的写法, 获取单例使用 get 方法
        private var instance2: LazyNotThreadSafe? = null

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

线程安全的懒汉式单例

java实现

public class LazyThreadSafeSynchronized {
    private static LazyThreadSafeSynchronized INSTANCE;

    private LazyThreadSafeSynchronized(){}

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

kotlin实现

class LazyThreadSafeSynchronized private constructor() {
    companion object {
       private var instance: LazyThreadSafeSynchronized? = null

        @Synchronized
        fun get(): LazyThreadSafeSynchronized{
            if(instance == null) instance = LazyThreadSafeSynchronized()
            return instance!!
        }
    }
}

DoubleCheck

java实现

public class LazyThreadSafeDoubleCheck {
    private static volatile LazyThreadSafeDoubleCheck INSTANCE;

    private LazyThreadSafeDoubleCheck(){}

    public static LazyThreadSafeDoubleCheck getInstance(){
        if(INSTANCE == null){
            synchronized (LazyThreadSafeDoubleCheck.class){
                if(INSTANCE == null) {
                    //初始化时分为实例化和赋值两步, 尽管我们把这一步写成下面的语句,
                    // 但Java虚拟机并不保证其他线程『眼中』这两步的顺序究竟是怎么样的
                    INSTANCE = new LazyThreadSafeDoubleCheck();
                }
            }
        }
        return INSTANCE;
    }
}

kotlin实现

class LazyThreadSafeDoubleCheck private constructor(){
    companion object{
        val instance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED){
            LazyThreadSafeDoubleCheck()
        }

        private @Volatile var instance2: LazyThreadSafeDoubleCheck? = null

        fun get(): LazyThreadSafeDoubleCheck {
            if(instance2 == null){
                synchronized(this){
                    if(instance2 == null)
                        instance2 = LazyThreadSafeDoubleCheck()
                }
            }
            return instance2!!
        }
    }
}

静态内部类单例

java实现

public class LazyThreadSafeStaticInnerClass {

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

    private LazyThreadSafeStaticInnerClass(){}

    public static LazyThreadSafeStaticInnerClass getInstance(){
        return Holder.INSTANCE;
    }
}

kotlin实现

class LazyThreadSafeStaticInnerObject private constructor(){
    companion object{
        fun getInstance() = Holder.instance
    }

    private object Holder{
        val instance = LazyThreadSafeStaticInnerObject()
    }
}

懒汉式单例

懒汉式单例在第一次使用时才会创建实例,适用于实例创建开销较大的情况。

class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
        @Synchronized fun getInstance(): Singleton {
            if (instance == null) {
                instance = Singleton()
            }
            return instance!!
        }
    }
}

原理说明

  • 使用private constructor()私有化构造函数,防止外部直接实例化对象。
  • 通过companion object声明单例对象,并使用getInstance()方法获取单例实例。
  • getInstance()方法中进行实例化,确保只有在需要时才会创建对象。
  • 使用Synchronized关键字,保证线程安全。

饿汉式单例

饿汉式单例在类加载时就创建实例,保证了线程安全,但可能会造成资源浪费。

object Singleton {
    // 单例对象
}

原理说明

  • 使用object关键字声明单例对象,该对象在类加载时立即被实例化。
  • JVM会保证在任何线程访问该对象之前,该对象已经被初始化完毕,确保线程安全。

双重检查锁

双重检查锁机制在懒汉式的基础上增加了线程安全性和性能。

class Singleton private constructor() {
    companion object {
        @Volatile private var instance: Singleton? = null
        fun getInstance(): Singleton {
            return instance ?: synchronized(this) {
                instance ?: Singleton().also { instance = it }
            }
        }
    }
}

原理说明

  • 使用@Volatile关键字确保instance字段的可见性,防止多线程环境下出现指令重排序导致的问题。
  • 通过双重检查(Double-Checked)机制,在第一次调用getInstance()时进行加锁,确保只有一个线程能够创建实例。

静态内部类

使用静态内部类来实现单例模式,利用类加载机制保证线程安全。

class Singleton private constructor() {
    companion object {
        val instance = Holder.INSTANCE
    }

    private object Holder {
        val INSTANCE = Singleton()
    }
}

原理说明

  • 将单例类的构造函数私有化,避免外部直接实例化。
  • 通过一个静态内部类来持有单例实例,利用类加载机制保证了线程安全和延迟加载的效果。

枚举类

利用枚举类的特性,保证了单例的实现。

enum class Singleton {
    INSTANCE
}

原理说明

  • 枚举类在Java和Kotlin中都是线程安全的,并且只会被装载一次。
  • 利用枚举类的单例特性,可以直接通过Singleton.INSTANCE获取单例实例,保证了线程安全和延迟加载。
  • 保证序列化与反序列化安全
  • 避免反射问题

结语

Kotlin提供了多种实现单例模式的方式,每种方式都有其自身的优缺点,大家可以根据实际需求选择合适的方式。无论是懒汉式、饿汉式还是双重检查锁等等,都能够确保在应用程序中只有一个实例存在。

相关文章
|
6天前
|
安全 Kotlin
Kotlin教程笔记(23) -作用域函数
Kotlin教程笔记(23) -作用域函数
20 6
|
6天前
|
设计模式 Java Kotlin
Kotlin教程笔记(56) - 改良设计模式 - 装饰者模式
Kotlin教程笔记(56) - 改良设计模式 - 装饰者模式
14 2
|
6天前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
11 2
|
7天前
|
Java 开发者 Kotlin
Kotlin教程笔记(14) - 伴生对象与静态成员
Kotlin教程笔记(14) - 伴生对象与静态成员
14 3
|
7天前
|
Java Kotlin
Kotlin教程笔记(13) - 类及成员的可见性
Kotlin教程笔记(13) - 类及成员的可见性
17 3
|
7天前
|
NoSQL Redis Kotlin
Kotlin教程笔记(17) - 属性代理
Kotlin教程笔记(17) - 属性代理
|
10天前
|
人工智能 Scala Kotlin
Kotlin教程笔记(8) - 运算符与中缀表达式
Kotlin教程笔记(8) - 运算符与中缀表达式
|
11天前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
|
1月前
|
设计模式 安全 Java
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
|
3月前
|
设计模式 数据库连接 PHP
PHP中的设计模式:提升代码的可维护性与扩展性在软件开发过程中,设计模式是开发者们经常用到的工具之一。它们提供了经过验证的解决方案,可以帮助我们解决常见的软件设计问题。本文将介绍PHP中常用的设计模式,以及如何利用这些模式来提高代码的可维护性和扩展性。我们将从基础的设计模式入手,逐步深入到更复杂的应用场景。通过实际案例分析,读者可以更好地理解如何在PHP开发中应用这些设计模式,从而写出更加高效、灵活和易于维护的代码。
本文探讨了PHP中常用的设计模式及其在实际项目中的应用。内容涵盖设计模式的基本概念、分类和具体使用场景,重点介绍了单例模式、工厂模式和观察者模式等常见模式。通过具体的代码示例,展示了如何在PHP项目中有效利用设计模式来提升代码的可维护性和扩展性。文章还讨论了设计模式的选择原则和注意事项,帮助开发者在不同情境下做出最佳决策。