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

相关文章
|
7天前
|
Kotlin 索引
Kotlin教程笔记(22) -常见高阶函数
Kotlin教程笔记(22) -常见高阶函数
|
7天前
|
Kotlin
Kotlin教程笔记(21) -高阶函数与函数引用
Kotlin教程笔记(21) -高阶函数与函数引用
|
7天前
|
Kotlin
Kotlin教程笔记(20) - 枚举与密封类
Kotlin教程笔记(20) - 枚举与密封类
18 3
|
7天前
|
Java Kotlin
Kotlin教程笔记(19) - 内部类
Kotlin教程笔记(19) - 内部类
18 3
|
7天前
|
安全 Kotlin
Kotlin教程笔记(23) -作用域函数
Kotlin教程笔记(23) -作用域函数
|
7天前
|
安全 IDE Java
Kotlin教程笔记(3) - 空类型和智能类型转换
Kotlin教程笔记(3) - 空类型和智能类型转换
|
7天前
|
存储 前端开发 Java
Kotlin教程笔记(18) - 数据类
Kotlin教程笔记(18) - 数据类
11 0
|
14天前
|
设计模式 安全 Java
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
|
2月前
|
设计模式 数据库连接 PHP
PHP中的设计模式:提升代码的可维护性与扩展性在软件开发过程中,设计模式是开发者们经常用到的工具之一。它们提供了经过验证的解决方案,可以帮助我们解决常见的软件设计问题。本文将介绍PHP中常用的设计模式,以及如何利用这些模式来提高代码的可维护性和扩展性。我们将从基础的设计模式入手,逐步深入到更复杂的应用场景。通过实际案例分析,读者可以更好地理解如何在PHP开发中应用这些设计模式,从而写出更加高效、灵活和易于维护的代码。
本文探讨了PHP中常用的设计模式及其在实际项目中的应用。内容涵盖设计模式的基本概念、分类和具体使用场景,重点介绍了单例模式、工厂模式和观察者模式等常见模式。通过具体的代码示例,展示了如何在PHP项目中有效利用设计模式来提升代码的可维护性和扩展性。文章还讨论了设计模式的选择原则和注意事项,帮助开发者在不同情境下做出最佳决策。
|
17天前
|
设计模式 开发者 Python
Python编程中的设计模式:工厂方法模式###
本文深入浅出地探讨了Python编程中的一种重要设计模式——工厂方法模式。通过具体案例和代码示例,我们将了解工厂方法模式的定义、应用场景、实现步骤以及其优势与潜在缺点。无论你是Python新手还是有经验的开发者,都能从本文中获得关于如何在实际项目中有效应用工厂方法模式的启发。 ###