• 设计模式——1. 单例模式

    1. 原理

    单例模式（Singleton Pattern）用于确保一个类只有一个实例，并提供一个全局访问点以访问该实例。这意味着无论在何处请求该类的实例，都将返回相同的唯一实例。单例模式常常用于需要共享资源，或需要限制某些资源在系统中的访问次数的情况下。

    2. 使用的场景

    单例模式在许多应用场景中都有用，特别是在需要确保全局只有一个实例存在的情况下。以下是一些常见的单例模式应用场景：

    1. 线程池：在多线程环境中，使用单例模式可以创建一个线程池，确保全局只有一个线程池实例来管理线程的生命周期。
    2. 数据库连接池：在需要频繁访问数据库的应用中，单例模式可以用于管理数据库连接，以减少资源消耗和提高性能。
    3. 配置管理器：单例模式可以用于创建一个全局的配置管理器，以提供应用程序配置参数的访问和管理。
    4. 日志记录器：在应用程序中记录日志时，单例模式可以用于创建一个全局的日志记录器，以确保所有的日志消息都写入同一个日志文件。
    5. 缓存管理：在需要缓存数据以提高性能的情况下，可以使用单例模式来管理缓存，确保只有一个缓存实例存在。
    6. 计数器或计时器：单例模式可以用于创建全局的计数器或计时器，用于跟踪应用程序中的事件或操作次数。
    7. 窗口管理器：在图形用户界面应用程序中，单例模式可以用于创建一个全局的窗口管理器，以管理应用程序窗口的创建、关闭等操作。
    8. 应用程序上下文：在某些情况下，需要在整个应用程序中共享某些状态或配置信息，可以使用单例模式来创建应用程序上下文对象。
    9. 硬件管理：在需要访问硬件资源的应用中，可以使用单例模式来管理硬件资源的访问，以防止冲突和资源浪费。
    10. 全局对象管理：在某些情况下，需要确保全局只有一个实例的对象，以便在整个应用程序中共享数据或状态。

    总之，单例模式在需要管理全局状态、资源或对象的情况下非常有用，它确保了全局只有一个实例存在，并提供了全局访问点，以方便在整个应用程序中使用该实例。然而，需要谨慎使用单例模式，以确保不引入不必要的全局状态和依赖关系。

    3. Python应用例子

    一个具体的应用场景是创建一个全局的日志记录器（Logger），以确保整个应用程序都使用相同的日志记录配置和实例。

    以下是一个基于Python的具体单例模式应用场景示例，其中我们将创建一个全局日志记录器来记录应用程序的日志消息：

    # logger.py
import logging

class Logger:
    def __init__(self, log_file):
        self.log_file = log_file
        logging.basicConfig(filename=log_file, level=logging.INFO)

    def log(self, message):
        logging.info(message)

logger_instance = None
def get_logger():
    global logger_instance
    if not logger_instance:
        logger_instance = Logger("app.log")
    return logger_instance

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在上述示例中，我们创建了一个 Logger 类，用于初始化日志记录器，并提供一个 log 方法用于记录日志消息。我们使用了 Python 的内置 logging 模块来处理日志记录。

    在 get_logger 函数中，我们使用一个全局变量 logger_instance 来存储日志记录器的唯一实例。如果实例不存在，它将创建一个新的 Logger 实例，否则返回已存在的实例。

    现在，我们可以在应用程序的不同部分使用 get_logger 函数来获取全局的日志记录器实例，并记录日志消息：

    # main.py
from logger import get_logger

def main():
    logger = get_logger()
    logger.log("This is a log message.")
    logger.log("Another log message.")

if __name__ == "__main__":
    main()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    在这个示例中，我们通过 get_logger 函数获取全局的日志记录器实例，并使用它来记录日志消息。无论在应用程序的哪个部分调用 get_logger，都将获得相同的日志记录器实例，确保了日志的一致性和全局可访问性。

    这个示例展示了如何使用单例模式来创建全局的日志记录器，以确保整个应用程序都共享相同的日志记录配置和实例。

    4. 实现方式

    单例模式通常包括以下要素：

    1. 私有构造函数（Private Constructor）：单例类的构造函数被设置为私有，以防止通过常规方式创建多个实例。
    2. 私有静态变量（Private Static Variable）：单例类内部通常包含一个私有的静态变量，用于存储唯一的实例。
    3. 公有静态方法（Public Static Method）：通常提供一个公有的静态方法，允许客户端代码获取该单例实例。这个方法通常叫做 getInstance()。

    实现单例模式的方式有多种，以下是两种常见的实现方式：

    4.1 饿汉式（Eager Initialization）

    在类加载时就创建单例实例，并在首次访问时返回该实例。这种方式简单，但可能会导致资源浪费，因为无论是否使用实例，都会创建对象。例如：

    class EagerSingleton:
    # 创建类级别的变量，并在类加载时初始化
    _instance = EagerSingleton()

    def __init__(self):
        self.value = None

    @staticmethod
    def get_instance():
        return EagerSingleton._instance

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    在上述示例中，我们创建了一个 EagerSingleton 类，并在类定义中直接初始化了一个类级别的变量 _instance。这个变量在类加载时就会被初始化，因此它是饿汉式单例模式的实现。

    你可以在其他地方导入 EagerSingleton 类并获取其单例实例，如下所示：

    if __name__ == "__main__":
    instance1 = EagerSingleton.get_instance()
    instance1.value = 42
    
    instance2 = EagerSingleton.get_instance()
    
    print(instance2.value)  # 输出 42

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在这个示例中，instance1 和 instance2 都是同一个实例，因为在类加载时就已经创建了实例。这确保了线程安全，并且不需要进行额外的同步操作。

    这样，你就成功地实现了饿汉式单例模式，以确保在类加载时就创建单例实例。

    4.2 懒汉式（Lazy Initialization）

    在第一次请求实例时才创建对象，以延迟实例化，可以节省资源。但需要考虑多线程情况下的线程安全问题，通常使用双重检查锁定等机制来保证线程安全。

    class LazySingleton:
    def __init__(self):
        self.value = None

    @staticmethod
    def get_instance():
        if not hasattr(LazySingleton, "_instance"):
            LazySingleton._instance = LazySingleton()
        return LazySingleton._instance

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    使用单例模式可以确保全局只有一个实例，这对于管理共享资源、日志记录、数据库连接池等情况非常有用。然而，在某些情况下，单例模式可能会引入全局状态，需要小心使用，以确保不引发不必要的复杂性和依赖关系。

    在上述示例中，我们创建了一个 LazySingleton 类，使用了一个静态方法 get_instance 来获取单例实例。在该方法内，我们使用 hasattr 检查是否已经创建了单例实例，如果没有，则创建一个新的实例并将其存储在 _instance 属性中。

    现在，你可以在其他模块中导入 LazySingleton 类并获取懒汉式单例实例：

    from lazy_singleton import LazySingleton

if __name__ == "__main__":
    instance1 = LazySingleton.get_instance()
    instance1.value = 42
    
    instance2 = LazySingleton.get_instance()
    
    print(instance2.value)  # 输出 42

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    在这个示例中，我们首先获取 LazySingleton 类的单例实例 instance1，并设置其属性值。然后，再次获取实例 instance2 时，它仍然是相同的实例，因此可以访问相同的属性值。

    这样，你就成功地实现了一个懒汉式的单例模式，确保了在首次访问时才创建单例实例。注意，虽然 Python 模块级别的变量在首次导入时会执行，但它们仍然是懒汉式的，因为它们只有在首次访问时才会初始化。

    5. Java/golang/javascrip/C++ 实现方式

    5.1 Java实现单例模式

    5.1.1 饿汉式

    public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() { }

    public static Singleton getInstance() {
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    5.1.2 懒汉式

    public class Singleton {
    private static Singleton instance;

    private Singleton() { }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    5.2 Golang实现单例模式

    5.2.1 饿汉式

    使用包级别的变量和init函数来实现。以下是一个示例：

    package singleton

import (
    "sync"
)

type Singleton struct {
    value int
}

var instance *Singleton

func init() {
    // 在 init 函数中创建单例实例
    instance = &Singleton{value: 0}
}

// GetInstance 返回饿汉式单例实例
func GetInstance() *Singleton {
    return instance
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    在上述示例中，我们创建了一个名为 Singleton 的结构体来表示单例对象，并在包的 init 函数中创建了单例实例。由于 init 函数在包加载时自动执行，因此实例会在程序启动时初始化。

    然后，通过 GetInstance 函数来获取饿汉式单例实例。

    在其他 Go 文件中，导入 singleton 包并调用 GetInstance 函数来获取该单例对象的实例：

    package main

import (
    "fmt"
    "your/package/path/singleton"
)

func main() {
    // 获取饿汉式单例实例
    instance := singleton.GetInstance()

    // 使用单例实例进行操作
    fmt.Printf("Value: %d\n", instance.value)

    // 修改单例实例的值
    instance.value = 42

    // 再次获取单例实例，仍然返回相同的实例
    instance2 := singleton.GetInstance()
    fmt.Printf("Value (After Update): %d\n", instance2.value)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    5.2.2 懒汉式

    使用包级别的变量和sync.Once来确保线程安全的延迟初始化。以下是一个示例：

    package singleton

import (
    "sync"
)

type Singleton struct {
    value int
}

var instance *Singleton
var once sync.Once

// GetInstance 返回懒汉式单例实例
func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{value: 0}
    })
    return instance
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    在上述示例中，我们创建了一个名为 Singleton 的结构体来表示单例对象。使用了 sync.Once 来确保 GetInstance 函数只会执行一次初始化操作，从而保证了懒汉式单例模式的线程安全性和延迟初始化。

    在其他 Go 文件中，导入 singleton 包并调用 GetInstance 函数来获取该单例对象的实例：

    package main

import (
    "fmt"
    "your/package/path/singleton"
)

func main() {
    // 获取懒汉式单例实例
    instance1 := singleton.GetInstance()

    // 使用单例实例进行操作
    fmt.Printf("Value: %d\n", instance1.value)

    // 修改单例实例的值
    instance1.value = 42

    // 再次获取单例实例，仍然返回相同的实例
    instance2 := singleton.GetInstance()
    fmt.Printf("Value (After Update): %d\n", instance2.value)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    这样，你就成功地实现了懒汉式单例模式，确保了在首次访问时才创建单例实例，并保证了线程安全性。请确保将 your/package/path 替换为实际的包路径。

    5.3 Javascript实现单例模式

    5.3.1 懒汉式

    在 JavaScript 中，使用闭包来实现懒汉式单例模式。以下是一个示例：

    let LazySingleton = (function () {
    let instance;

    function createInstance() {
        // 在这里创建实例
        return {
            value: 0,
        };
    }

    return {
        getInstance: function () {
            if (!instance) {
                instance = createInstance();
            }
            return instance;
        },
    };
})();

// 获取懒汉式单例实例
let instance1 = LazySingleton.getInstance();
console.log(instance1.value);  // 输出 0

// 修改单例实例的值
instance1.value = 42;

// 再次获取单例实例，仍然返回相同的实例
let instance2 = LazySingleton.getInstance();
console.log(instance2.value);  // 输出 42

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    在这个示例中，我们使用了一个立即执行的函数来创建一个闭包，其中 instance 用于存储单例实例。getInstance 方法检查是否已经存在实例，如果不存在，则调用 createInstance 函数来创建实例。

    5.3.2 饿汉式

    在 JavaScript 中，直接创建实例并将其导出，以实现饿汉式单例模式。以下是一个示例：

    let EagerSingleton = {
    value: 0,
};

// 导出饿汉式单例实例
export default EagerSingleton;

// 在其他模块中导入并使用
import EagerSingleton from './EagerSingleton.js';

// 获取饿汉式单例实例
console.log(EagerSingleton.value);  // 输出 0

// 修改单例实例的值
EagerSingleton.value = 42;

// 再次获取单例实例，仍然返回相同的实例
console.log(EagerSingleton.value);  // 输出 42

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这个示例中，我们直接创建了 EagerSingleton 对象，并将其导出，以确保在程序初始化时就已经存在实例。

    5.4 C++实现单例模式

    5.4.1 饿汉式：

    使用静态成员变量和互斥锁来实现线程安全的懒汉式单例模式。以下是一个示例：

    #include 
#include 

class LazySingleton {
public:
    static LazySingleton& getInstance() {
        std::call_once(onceFlag, [&]() {
            instance = new LazySingleton();
        });
        return *instance;
    }

    // 在这里定义单例类的其他成员和方法

private:
    LazySingleton() {
        // 在这里进行初始化操作
    }

    ~LazySingleton() {
        // 在这里进行清理操作
    }

    // 阻止拷贝构造函数和赋值运算符的调用
    LazySingleton(const LazySingleton&) = delete;
    LazySingleton& operator=(const LazySingleton&) = delete;

    static LazySingleton* instance;
    static std::once_flag onceFlag;
};

LazySingleton* LazySingleton::instance = nullptr;
std::once_flag LazySingleton::onceFlag;

int main() {
    // 获取懒汉式单例实例
    LazySingleton& instance1 = LazySingleton::getInstance();
    instance1.value = 42;

    // 再次获取单例实例，仍然返回相同的实例
    LazySingleton& instance2 = LazySingleton::getInstance();
    std::cout << instance2.value << std::endl;  // 输出 42

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    在示例中，我们使用了 std::call_once 函数来确保 instance 只会被创建一次，并使用了 std::once_flag 来保证线程安全性。

    5.4.2 懒汉式

    使用静态成员变量来实现饿汉式单例模式。以下是一个示例：

    #include 

class EagerSingleton {
public:
    static EagerSingleton& getInstance() {
        return instance;
    }

    // 在这里定义单例类的其他成员和方法

private:
    EagerSingleton() {
        // 在这里进行初始化操作
    }

    ~EagerSingleton() {
        // 在这里进行清理操作
    }

    // 阻止拷贝构造函数和赋值运算符的调用
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;

    static EagerSingleton instance;
};

EagerSingleton EagerSingleton::instance;

int main() {
    // 获取饿汉式单例实例
    EagerSingleton& instance1 = EagerSingleton::getInstance();
    instance1.value = 42;

    // 再次获取单例实例，仍然返回相同的实例
    EagerSingleton& instance2 = EagerSingleton::getInstance();
    std::cout << instance2.value << std::endl;  // 输出 42

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    在这个示例中，我们直接创建了 EagerSingleton 类的静态成员变量 instance，确保在程序初始化时即创建实例。

    6. 练习题

    假设你正在开发一个电子商务平台的购物车功能。购物车是一个全局共享的对象，用于存储用户在不同页面上添加到购物车的商品。请使用单例设计模式来实现购物车对象，并确保它在整个应用程序中只有一个实例。

    要求：

    1. 创建一个名为 ShoppingCart 的单例类，用于表示购物车。
    2. 确保 ShoppingCart 类只能有一个实例，并提供一种方法来获取该实例。
    3. 实现购物车的基本功能，包括添加商品、删除商品、获取购物车内容等方法。
    4. 编写测试代码来验证购物车对象的单例性质，即多次获取购物车实例应该是同一个实例。

    你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

  • 相关阅读:
    LeetCode 118. 杨辉三角(及119)
    管理系统权限篇
    机器学习/深度学习模型的8个测试属性
    Python实现给图片加水印功能
    【Image captioning】ruotianluo/self-critical.pytorch之4—模型训练之train.py代码解析
    uniapp开发h5引入第三方js（sdk）
    快速乘详解
    郑州灵活用工平台的市场价值大吗？
    yum ｜ dnf命令打补丁-升级安装包
    苹果Ios系统app应用程序开发者如何获取IPA文件签名证书时需要注意什么？
  • 原文地址：https://blog.csdn.net/guohuang/article/details/133213079