这是清除C＃MemoryCache的好方法吗？

Question

我已经阅读了有关在C＃中清除MemoryCache的问题和答案。 有许多建议，例如：1。枚举缓存，并删除所有项目 - 根据其他人，这不好，让枚举器锁定整个事情，并发生各种启示录，引用文档的一部分，我没有找到，并显示警告，我没有重现。 无论如何，我认为这不是一个非常有效的解决方案。

1. 将密钥存储在单独的集合中，并迭代该密钥，以从缓存中删除项目。 - 除了这听起来不是很安全，它听起来也不是很有效。

2. 处理旧缓存，并创建一个新缓存 - 听起来不错，这是一个明显的问题，并且在几条评论中指出，现有的旧缓存引用可能会带来问题。 当然，行动的顺序很重要，你必须为旧的参考保存一个参考，创建一个旧的参考代替旧的参考，并处理旧的 - 不是每个人似乎都注意到这个小细微差别。

所以现在怎么办？ 我的一位同事建议使用MemoryCache来解决我的问题，他将缓存对象包装在另一个类中，可以选择获取密钥（如果需要可以从db加载），删除密钥或清除缓存。 前两个现在不重要，第三个很有趣。 我已经使用了第三个解决方案，除了“我保证，除了我自己的实现之外，没有任何对MemoryCache对象的额外引用”。 所以相关的代码是：

构造函数：

public MyCache()
{
    _cache = new MemoryCache("MyCache");
}

清除缓存：

public void ClearCacheForAllUsers()
{
    var oldCache = _cache;
    _cache = new MemoryCache("MyCache");
    oldCache.Dispose();
}

_cache是​​私有的MemoryCache对象。

这会在多线程环境中引起问题吗？ 我有一些关于并行调用read和dispose的问题。 我应该实现某种锁定机制，它允许并发读取，但是导致清除缓存功能等待当前读取在缓存上完成？

我的猜测是肯定的，它需要实现这一点，但我想在获得它之前获得一些见解。

罗伯特

在Voo的回答中编辑1：保证，“包装器”（MyCache）之外的任何人都不会获得对_cache对象的引用。 我的担心如下：

T1:
MyCache.ClearAll()
    var oldCache = _cache
T2:
MyCache.GetOrReadFromDb("stuff")
T1:
    _cache=new MemoryCache("MyCache")
    oldCache.Dispose()
T2:
    *something bad*

除了仍然使用旧缓存的T2线程之外，这不是首选，但我可以使用的东西，可能存在这样的情况：Get方法以某种方式访问​​处于已处置状态的旧缓存，或者读取没有数据的新缓存？

想象一下GetOrReadFromDb函数是这样的：

public object GetOrReadFromDb(string key)
{
    if(_cache[key]==null)
    {
        //Read stuff from DB, and insert into the cache
    }
    return _cache[key];
}

我认为有可能将控制从读取线程中删除，并在清除之后，例如在从db读取之后，以及在返回_chache [key]值之前，这可能会导致问题。 这是一个真正的问题吗？

Answer 1

您的解决方案的问题是它引入了可能的竞争条件，需要丑陋的锁或其他线程同步解决方案。

相反，请使用内置解决方案。

您可以使用自定义ChangeMonitor类从缓存中清除项目。 您可以将ChangeMonitor实例添加到调用MemoryCache.Set时设置的CacheItemPolicy的ChangeMonitors属性中。

例如：

class MyCm : ChangeMonitor
{
    string uniqueId = Guid.NewGuid().ToString();

    public MyCm()
    {
        InitializationComplete();
    }

    protected override void Dispose(bool disposing) { }

    public override string UniqueId
    {
        get { return uniqueId; }
    }

    public void Stuff()
    {
        this.OnChanged(null);
    }
}

用法示例：

        var cache = new MemoryCache("MyFancyCache");
        var obj = new object();
        var cm = new MyCm();
        var cip = new CacheItemPolicy();
        cip.ChangeMonitors.Add(cm);

        cache.Set("MyFancyObj", obj, cip);

        var o = cache.Get("MyFancyObj");
        Console.WriteLine(o != null);

        o = cache.Get("MyFancyObj");
        Console.WriteLine(o != null);

        cm.Stuff();

        o = cache.Get("MyFancyObj");
        Console.WriteLine(o != null);

        o = cache.Get("MyFancyObj");
        Console.WriteLine(o != null);

Answer 2

从未使用过MemoryCache类，但是有明显的竞争条件。 当另一个线程T2正在执行ClearCacheForAllUsers线程T1可以调用GetElement （或者你称之为的任何东西）。

然后会发生以下情况：

T1:
reg = _cache
T2:
oldCache = _cache
_cache = new MemoryCache("MyCache")
oldCache.Dispose()
T1:
reg.Get()   // Ouch bad! Dispose tells us this results in "unexpected behavior"

简单的解决方案是引入同步。

如果锁定是不可接受的，你可以使用一些聪明的技巧，但最简单的解决方案是使用Finalize我会说。 当然，通常是一个坏主意，但假设缓存所做的唯一事情就是耗尽内存，所以只有在内存压力下才能收集缓存而不会因为让GC担心而无需担心竞争条件关于它。 请注意， _cache必须是易失性的。

另一种可能的方法是，作为一个实现细节， Get显然总是在释放缓存后返回null 。 在这种情况下，除了在极少数情况下，您可以避免大部分时间锁定。 虽然这是实现定义的，但我不想亲自依赖这么小的细节。