懒加载 | Ciallo～(∠・ω< )⌒☆ ccのblog

懒加载（Lazy Initialization 或 Lazy Loading）是一种设计模式或编程技巧，它的核心思想是：延迟初始化资源，只有在真正需要的时候才创建或加载这些资源。

懒加载的特点

避免不必要的开销
- 如果资源加载非常耗时或占用大量内存，懒加载可以减少程序启动时的资源占用。
提升性能
- 只有在资源被真正需要时才加载，减少了程序的启动时间。
按需加载
- 资源是否加载取决于程序运行时的实际需求，可能避免加载某些资源。

懒加载的使用场景

单例模式
- 在单例模式中，实例对象通常会在第一次访问时才创建。
- 例如，你的 Logger 类的实现：
  1
  2
  3
  4
  Logger &Logger::instance() {
  static Logger logger; // 静态变量只在第一次调用时初始化
  return logger;
  }
  - Logger 对象只有在调用 Logger::instance() 时才会被创建，而不是程序启动时。

文件或资源加载

某些大文件、图像、数据库连接等，只有当它们真正被使用时才加载：

class Image {
    std::string filePath;
    bool loaded = false;

public:
    void load() {
        if (!loaded) {
            std::cout << "Loading image from: " << filePath << std::endl;
            loaded = true;
        }
    }
};

在这里，load() 方法只会在需要时加载图像。

Web开发
- 某些页面的资源（如图片、视频等）可能只有当用户滚动到相关区域时才加载，减少初始页面加载时间。

数据库连接或远程服务

某些昂贵的资源，比如数据库连接或远程 API 的初始化，可以延迟到第一次调用时：

class DatabaseConnection {
    std::unique_ptr<Connection> conn;

public:
    Connection* getConnection() {
        if (!conn) {
            conn = std::make_unique<Connection>("database_url");
        }
        return conn.get();
    }
};

懒加载的优缺点

优点

节约资源
- 如果某些资源没有被使用，那么它们就不会被初始化，节省内存和 CPU 开销。
提升性能
- 程序启动时不需要一次性加载所有资源，减少启动时间。
动态性
- 根据实际需要按需加载，增加程序的灵活性。

缺点

可能导致延迟
- 当资源在运行时第一次被访问时，懒加载会增加一定的初始化开销，可能导致短暂的延迟。
线程安全问题
- 在多线程环境中，如果多个线程同时访问未初始化的资源，可能会导致竞争条件或重复初始化。需要通过加锁或使用线程安全的机制（如 C++11 的静态局部变量）解决。

懒加载与饿加载对比

特性	懒加载	饿加载（Eager Loading）
加载时机	只有在需要时才加载资源	程序启动时立即加载资源
性能开销	程序启动时较快，首次使用时可能有延迟	程序启动时较慢，但运行时无需等待
资源消耗	只有用到的资源才会加载，节约内存	所有资源都被加载，可能造成浪费
线程安全	需要确保初始化过程的线程安全	初始化时线程安全问题相对较少
适用场景	资源加载成本高，且不一定被全部使用	资源较少，或所有资源都会被使用

懒加载的实现方式

1. 静态局部变量

C++ 中常用懒加载方式，利用静态局部变量的特性：

Logger &Logger::instance() {
    static Logger logger;
    return logger;  // 只有第一次调用时，logger 才会被初始化
}

2. 延迟初始化变量

用一个标志位来判断是否已加载资源：

class LazyObject {
    std::unique_ptr<Resource> resource;
    
 public:
    Resource* getResource() {
        if (!resource) {
            resource = std::make_unique<Resource>();
        }
        return resource.get();
    }
};

3. 双重检查锁（用于多线程）

多线程情况下的懒加载，可以用双重检查锁：

class Singleton {
    static Singleton* instance;
    static std::mutex mtx;

 public:
    static Singleton* getInstance() {
        if (!instance) {
            std::lock_guard<std::mutex> lock(mtx);
            if (!instance) {
                instance = new Singleton();
            }
        }
        return instance;
    }
};