这段 C# 代码是否应该重构以使用 Lazy<T> 类？

Question

我有如下代码，可能会被多个Web请求同时调用。因此，我不希望第二个及之后的请求击中数据库，而是等待第一个请求完成后再处理。

是否应该重构这段代码，使用Lazy<T>类？如果同时发生10次对Lazy<T>代码块的调用，那么其中9个调用是否会等待第一个调用完成后再执行？

public class ThemeService : IThemeService
{
    private static readonly object SyncLock = new object();
    private static IList<Theme> _themes;
    private readonly IRepository<Theme> _themeRepository;

    <snip snip snip>

    #region Implementation of IThemeService

    public IList<Theme> Find()
    {
        if (_themes == null)
        {
            lock (SyncLock)
            {
                if (_themes == null)
                {
                    // Load all the themes from the Db.
                    _themes = _themeRepository.Find().ToList();
                }
            }
        }

        return _themes;
    }

    <sip snip snip>

    #endregion
}

- Pure.Krome

---

它简单地被称为类型。更具体地说，它是一个类。 - BoltClock

Answer 1

是的，你可以使用 Lazy<T>

来自MSDN:

默认情况下，Lazy对象是线程安全的。也就是说，如果构造函数没有指定线程安全性质，它创建的Lazy对象是线程安全的。在多线程场景中，第一个访问线程安全的Lazy对象的Value属性的线程将其初始化，以供所有后续访问和所有线程共享相同的数据。因此，不管哪个线程初始化对象，竞争条件都是良性的。

是的，它不是关键字 - 它是.NET框架类，正式规范了懒惰初始化的常见需求，并提供了开箱即用的功能，因此您不必手动实现。

- BrokenGlass

Answer 2

正如@BrokenGlass所指出的那样，这是安全的。但我忍不住想做一个测试...... 只打印了一个线程ID...

private static Lazy<int> lazyInt;

// make it slow
private int fib()
{
    Thread.Sleep(1000);
    return 0;
}

public void Test()
{
    // when run prints the thread id
    lazyInt = new Lazy<int>(
        () =>
        {
            Debug.WriteLine("ID: {0} ", Thread.CurrentThread.ManagedThreadId);
            return fib();
        });

    var t1 = new Thread(() => { var x = lazyInt.Value; });
    var t2 = new Thread(() => { var x = lazyInt.Value; });
    var t3 = new Thread(() => { var x = lazyInt.Value; });

    t1.Start();
    t2.Start();
    t3.Start();

    t1.Join();
    t2.Join();
    t3.Join();
}

但是，哪一个更快？根据我得到的结果...

执行代码100次

[   Lazy: 00:00:01.003   ]
[  Field: 00:00:01.000   ]

执行代码100000000次

[   Lazy: 00:00:10.516   ]
[  Field: 00:00:17.969   ]

测试代码：

Performance.Test("Lazy", TestAmount, false,
    () =>
    {
        var laz = lazyInt.Value;
    });

Performance.Test("Field", TestAmount, false,
    () =>
    {
        var laz = FieldInt;
    });

测试方法：

public static void Test(string name, decimal times, bool precompile, Action fn)
{
    if (precompile)
    {
        fn();
    }

    GC.Collect();
    Thread.Sleep(2000);

    var sw = new Stopwatch();

    sw.Start();

    for (decimal i = 0; i < times; ++i)
    {
        fn();
    }

    sw.Stop();

    Console.WriteLine("[{0,15}: {1,-15}]", name, new DateTime(sw.Elapsed.Ticks).ToString("HH:mm:ss.fff"));
}

- BrunoLM