具有已知键列表的延迟加载缓存的多线程实现

Question

我正在用.Net 3.5开发一个多线程应用程序，该应用程序从数据库中存储的不同表中读取记录。 读数非常频繁，因此需要惰性加载缓存实现。 每个表都映射到一个C＃类，并具有一个字符串列，可用作缓存中的键。 另外，还要求定期刷新所有缓存的记录。 我本可以在每次读取时加锁来实现高速缓存，以确保线程安全的环境，但是随后我想到了另一种解决方案，该解决方案依赖于这样一个事实，即，它很容易获得所有可能的键的列表。

因此，这是我编写的第一个类，该类存储了用双重检查的锁定模式延迟加载的所有键的列表。 它还具有一种将静态请求的时间戳记存储在静态变量中的方法。

public class Globals
{
    private static object _KeysLock = new object();
    public static volatile List<string> Keys;
    public static void LoadKeys()
    {
        if (Keys == null)
        {
            lock (_KeysLock)
            {
                if (Keys == null)
                {
                    List<string> keys = new List<string>();
                    // Filling all possible keys from DB
                    // ...
                    Keys = keys;
                }
            }
        }
    }

    private static long refreshTimeStamp = DateTime.Now.ToBinary();
    public static DateTime RefreshTimeStamp
    {
        get { return DateTime.FromBinary(Interlocked.Read(ref refreshTimeStamp)); }
    }
    public static void NeedRefresh()
    {
        Interlocked.Exchange(ref refreshTimeStamp, DateTime.Now.ToBinary());
    }
}

然后，我写了CacheItem<T>类，该类是针对由键过滤的指定表T的单个缓存项的实现。 它具有用于延迟加载记录列表的Load方法和可存储上一次记录加载时间戳的LoadingTimeStamp属性。 请注意，记录静态列表将被替换为新的一个局部充满，然后LoadingTimeStamp被overritten了。

public class CacheItem<T>
{
    private List<T> _records;
    public List<T> Records
    {
        get { return _records; }
    }

    private long loadingTimestampTick;
    public DateTime LoadingTimestamp
    {
        get { return DateTime.FromBinary(Interlocked.Read(ref loadingTimestampTick)); }
        set { Interlocked.Exchange(ref loadingTimestampTick, value.ToBinary()); }
    }

    public void Load(string key)
    {
        List<T> records = new List<T>();
        // Filling records from DB filtered on key
        // ...
        _records = records;
        LoadingTimestamp = DateTime.Now;
    }
}

最后是Cache<T>类，该类将表T的缓存存储为静态Dictionary。 如您所见， Get方法首先将所有可能的键加载到缓存中（如果尚未完成的话），然后检查刷新的时间戳（两者均使用双重检查的锁定模式完成）。 即使有另一个线程正在锁中进行刷新，线程也可以安全地读取Get调用返回的实例中的记录列表，因为刷新线程不会修改列表本身，而是创建一个新的列表。

public class Cache<T>
{
    private static object _CacheSynch = new object();
    private static Dictionary<string, CacheItem<T>> _Cache = new Dictionary<string, CacheItem<T>>();
    private static volatile bool _KeysLoaded = false;

    public static CacheItem<T> Get(string key)
    {
        bool checkRefresh = true;
        CacheItem<T> item = null;
        if (!_KeysLoaded)
        {
            lock (_CacheSynch)
            {
                if (!_KeysLoaded)
                {
                    Globals.LoadKeys(); // Checks the lazy loading of the common key list
                    foreach (var k in Globals.Keys)
                    {
                        item = new CacheItem<T>();
                        if (k == key)
                        {
                            // As long as the lock is acquired let's load records for the requested key
                            item.Load(key);
                            // then the refresh is no more needed by the current thread
                            checkRefresh = false;
                        }
                        _Cache.Add(k, item);
                    }
                    _KeysLoaded = true;
                }
            }
        }
        // here the key is certainly contained in the cache
        item = _Cache[key];
        if (checkRefresh)
        {
            // let's check the timestamps to know if refresh is needed
            DateTime rts = Globals.RefreshTimeStamp;
            if (item.LoadingTimestamp < rts)
            {
                lock (_CacheSynch)
                {
                    if (item.LoadingTimestamp < rts)
                    {
                        // refresh is needed
                        item.Load(key);
                    }
                }
            }
        }
        return item;
    }
}

定期调用Globals.NeedRefresh()以确保将刷新记录。 该解决方案可以避免在每次读取高速缓存时锁定，因为高速缓存中已预先填充了所有可能的键：这意味着内存中的实例数将等于所有可能的键数（大约20个） ），以获取每个请求的类型T（所有T类型均约为100），但是仅对于所请求的键，记录列表并不为空。 请让我知道此解决方案是否存在线程安全问题或任何错误。 非常感谢你。

Answer 1

鉴于：

• 一次加载所有密钥，永不更改
• 您只需创建一次字典，就永远不会更改它
• CacheItem.Load是线程安全的，因为它只用新的完全初始化的列表替换了私有List<T>字段。

您根本不需要任何锁，因此可以简化代码。

锁定的唯一可能需求是防止并发尝试运行CacheItem.Load 。 就我个人而言，我只是让并发数据库访问运行，但是如果要阻止它，您可以在CacheItem.Load实现锁定。 或者从.NET 4中捏Lazy<T> ，并按照我对上一个问题的回答中的建议使用它。

另一个评论是您的刷新逻辑使用DateTime.Now （a）在夏令时结束时返回时钟的期间和（b）如果系统时钟已更新的情况下将无法按预期运行。

我会简单地使用一个静态整数值，每次调用NeedRefresh该值都会增加。

来自评论：

例如，如果两个线程……尝试同时加载公共的Globals.Keys，会发生什么情况？”

在应用程序启动时可能会发生一次的风险很小，但是那又如何呢？ 这将导致从数据库中两次读取20个密钥，但是对性能的影响可能微不足道。 而且，如果您真的想防止这种情况发生，则可以将任何锁定封装在Lazy<T>类的类中。

关于使用DateTime.Now的评论实际上是一个有趣的问题，但是我想我可以假设那些事件可能在不使用应用程序时发生。

您可以“假设”这一点，但不能保证。 您的机器可能会决定随时将其时间与时间服务器同步。

关于在NeedRefresh中使用整数的建议，我不明白如何将其与DateTime表示的每个记录列表状态进行比较。

据我所知，您仅使用DateTime来检查您的数据是在最近一次对NeedRefresh调用之前还是之后加载的。 因此，您可以将其替换为：

public static class Globals
{
    ...

    public static int Version { get {return _version; } }
    private static int _version;

    public static void NeedRefresh()
    {
        Interlocked.Increment(ref _version);
    }
}

public class CacheItem<T>
{
    public int Version {get; private set; }

    ...

    public void Load(string key)
    {
        Version = Globals.Version;

        List<T> records = new List<T>();
        // Filling records from DB filtered on key
        // ...
        _records = records;
    }
}

然后在访问缓存时：

item = _Cache[key];
if (item.Version < Globals.Version) item.Load();

**更新2 **

回应评论：

...如果一个线程试图读取Dictionary，而另一个线程在锁中向其中添加项目，则可能存在真正的完整性风险，不是吗？

您现有的代码仅在加载全局键之后立即将所有键添加到字典中，并且以后再也不会修改字典。 因此，这是线程安全的，只要在字典完全构建之前不分配_Cache属性即可：

var dictionary = new Dictionary<string, CacheItem<T>>(Global.Keys.Count);
foreach (var k in Globals.Keys)                       
{                           
    dictionary.Add(k, new CacheItem<T>());
}
_Cache = dictionary;