C# Lazy

最新推荐文章于 2024-04-23 20:03:53 发布

寒冰屋

最新推荐文章于 2024-04-23 20:03:53 发布

阅读量312

点赞数

分类专栏： CSharp.NET 文章标签： c# lazy

CSharp.NET 专栏收录该内容

1163 篇文章 53 订阅

订阅专栏

Lazy如何实现懒加载的？

Lazy如何保证线程安全的?

自动丢弃未使用的实例，是如何判断是否需要丢弃的？又是怎么丢弃的？

C# Lazy的缺点

Lazy的使用场景

Lazy<T> 是一个类，用于实现懒加载（Lazy Initialization）。懒加载是指对象的创建被推迟，直到第一次被使用时。Lazy<T> 允许你在第一次访问对象时进行初始化，这对于大型或资源密集型对象的性能优化非常有用。你可以通过提供一个委托（Delegate）来延迟初始化对象，Lazy<T> 确保所有线程使用同一个懒加载对象的实例，并且丢弃未使用的实例，从而优化内存使用。

延迟初始化（Lazy Initialization）：Lazy<T> 允许你将对象的创建推迟到首次访问时。
线程安全（Thread-Safe）：Lazy<T> 提供了线程安全的延迟初始化，确保在多线程环境中也能正确工作。
自动丢弃未使用的实例：如果对象未被使用，Lazy<T> 会自动丢弃初始化失败的实例，优化内存使用。
支持复杂的初始化逻辑：你可以提供一个委托，允许你在初始化对象时执行复杂的逻辑。
Value 属性：通过 Lazy<T>.Value 属性访问延迟初始化的对象。

Lazy如何实现懒加载的？

懒加载（Lazy Loading）是一种设计模式，它允许你将对象的创建推迟到实际需要的时候进行。在C#中，Lazy<T> 类实现了这个模式。当你使用Lazy<T>时，它会推迟目标对象的创建直到你第一次访问Lazy<T>的Value属性。这样，你可以在程序运行时避免不必要的初始化和资源消耗，提高性能。

具体原理是，Lazy<T> 内部使用了一个委托，该委托负责创建目标对象。当你第一次访问Lazy<T>的Value属性时，该委托会执行，实例化目标对象，并将其保存下来。随后的访问会直接返回已经创建好的对象，而不会再次执行委托。

Lazy<MyClass> lazyInstance = new Lazy<MyClass>(() => new MyClass());
MyClass myObject = lazyInstance.Value; // 对象在第一次访问时创建

Lazy如何保证线程安全的?

Lazy<T> 类提供了内建的线程安全机制，确保在多线程环境下也能正常工作。通过Lazy<T>，你可以实现延迟加载，而且无需担心线程安全性。Lazy<T> 内部使用了一种双重检查锁（Double-Check Locking）的机制，确保在多线程环境下只有一个线程会执行被延迟加载的对象的初始化操作。这意味着，Lazy<T> 会保证在多线程环境下只有一个线程会调用目标对象的构造函数，避免了竞态条件（Race Condition）的发生。

双重检查锁（Double-Check Locking）的机制

这种机制包含两个检查步骤，第一个检查在没有锁的情况下，确保只有一个线程会尝试初始化对象。第二个检查是在锁的情况下，确保只有一个线程能够进入临界区域，防止多个线程同时初始化对象。

具体来说，Lazy<T> 使用了双重检查锁机制来保证线程安全：

第一次检查（Without Lock）： 在没有锁的情况下，检查是否已经初始化了对象。如果对象已经初始化，直接返回它，否则进入第二个步骤。
加锁（Locking）： 确保只有一个线程能够进入临界区域。在进入临界区域后，再次检查对象是否已经初始化。如果没有初始化，进行初始化操作。

这种双重检查锁机制在Lazy<T> 类内部实现，确保了延迟加载的对象在多线程环境下的线程安全性。

自动丢弃未使用的实例，是如何判断是否需要丢弃的？又是怎么丢弃的？

1.没有被访问过的示例会需要丢弃，Lazy<T> 类的实例在第一次访问时进行初始化，之后会被缓存，确保所有线程都使用相同的初始化后的对象。如果想知道实例是否被访问过，可以观察初始化委托的执行次数。如果委托只执行了一次，说明实例只被访问过一次。Lazy<T> 类的设计确保了只有在第一次访问时执行初始化委托，之后的访问都使用缓存的实例，从而达到了节省资源的效果。

Lazy<T> lazyInstance = new Lazy<T>(() => CreateInstance());

// 检查实例是否已经被访问
if (lazyInstance.IsValueCreated)
{
    Console.WriteLine("实例已被访问过。");
}
else
{
    Console.WriteLine("实例未被访问过。");
}

T CreateInstance()
{
    // 实例的创建逻辑
    return new T();
}

2.使用Lazy时，实例的自动丢弃是通过垃圾回收（Garbage Collection）机制实现的。当一个Lazy实例不再被引用或者不再被需要时，它会成为垃圾回收的目标。垃圾回收器会定期检查程序中的对象，识别不再被引用的对象，并释放它们所占用的内存。当Lazy实例被垃圾回收时，它所持有的对象实例也会被销毁，从而实现了自动丢弃的效果。

C# Lazy的缺点

性能开销： 在第一次访问Lazy<T>对象时，需要进行初始化操作，这可能会引入一定的性能开销，特别是在初始化逻辑较复杂或耗时的情况下。
线程安全性： 默认情况下，Lazy<T>是线程安全的，但如果需要在多线程环境下共享实例，可能需要额外的线程同步措施，这会增加复杂性。
内存占用： 虽然Lazy<T>可以延迟对象的创建，但在对象创建后，它将一直占用内存，即使后续不再需要该对象。
不适用于某些场景： Lazy<T>适用于需要延迟初始化的场景，但并不适用于所有情况。在某些情况下，可能需要即时创建对象或使用其他设计模式。
引入额外复杂性： 在某些情况下，使用Lazy<T>可能会引入额外的复杂性，使代码变得难以理解和维护。

Lazy是否存在性能问题？

Lazy<T> 类型是为了延迟初始化而设计的，用于提高性能、避免资源浪费和减少内存需求。Lazy<T> 在实例化时不会立即创建对象，只有在第一次访问时才会实际进行初始化。因此，它不会导致性能问题，相反，它通常用于优化性能，特别是在需要创建大量对象时，但不一定需要立即使用这些对象的情况下。

但需要注意的是，如果初始化逻辑本身非常耗时，那么在第一次访问时会有一定的性能开销。但这并不是Lazy<T>的问题，而是由初始化逻辑引起的。

如果需要在多线程环境下共享实例怎么做？

使用Lazy<T>的线程安全模式： Lazy<T>类提供了一些线程安全的模式，例如LazyThreadSafetyMode.PublicationOnly和LazyThreadSafetyMode.ExecutionAndPublication。你可以根据需求选择适当的模式，确保在多线程环境下实例的安全共享。

Lazy<T> lazyInstance = new Lazy<T>(() => CreateInstance(), LazyThreadSafetyMode.ExecutionAndPublication);

使用lock语句： 在访问共享实例时使用lock语句，确保同时只有一个线程可以访问该实例。这样可以防止多个线程同时修改共享资源，保证线程安全。

private static object lockObject = new object();
private static SomeClass sharedInstance;

// 在需要访问共享实例的地方
lock (lockObject)
{
    // 访问共享实例
    sharedInstance.DoSomething();
}

使用Monitor类： Monitor类提供了与lock语句类似的功能，可以用于在多线程环境下实现线程同步。它提供了Enter和Exit方法来控制访问共享资源的线程。

private static object lockObject = new object();
private static SomeClass sharedInstance;

// 在需要访问共享实例的地方
Monitor.Enter(lockObject);
try
{
    // 访问共享实例
    sharedInstance.DoSomething();
}
finally
{
    Monitor.Exit(lockObject);
}

使用Concurrent命名空间中的集合： System.Collections.Concurrent命名空间提供了一组线程安全的集合类，例如ConcurrentDictionary<T>，ConcurrentQueue<T>，ConcurrentBag<T>等。你可以使用这些集合来共享数据，而不需要额外的锁定操作。

Lazy的使用场景

延迟加载大对象： 当你有一个大对象，希望在需要的时候再初始化，可以使用Lazy<T>。这样可以避免在应用程序启动时就加载大对象，提高了启动速度。
```
Lazy<BigObject> lazyObject = new Lazy<BigObject>(() => new BigObject());
BigObject obj = lazyObject.Value; // 在需要时初始化
```

单例模式的延迟初始化： Lazy<T> 可以用于实现线程安全的单例模式，确保只有一个实例被创建。

private static Lazy<SingletonClass> _instance = new Lazy<SingletonClass>(() => new SingletonClass());
public static SingletonClass Instance => _instance.Value;

按需加载集合： 你可以使用Lazy<T> 来按需加载集合，以节省内存和提高性能。例如，加载大型数据集。

Lazy<List<DataItem>> lazyData = new Lazy<List<DataItem>>(LoadDataFromDatabase);
List<DataItem> data = lazyData.Value; // 在需要时加载数据

多线程应用中的线程安全延迟初始化： Lazy<T> 提供了多种线程安全模式，可以确保在多线程环境下仍然能够安全地进行延迟初始化。
```
Lazy<ThreadSafeObject> lazyThreadSafeObject = new Lazy<ThreadSafeObject>(() => new ThreadSafeObject(), LazyThreadSafetyMode.ExecutionAndPublication);
```