3

我正在为 MVC Web 应用程序开发缓存管理器。对于这个应用程序，我有一些构建成本很高的非常大的对象。在应用程序的生命周期中，我可能需要根据用户请求创建几个这样的对象。构建后，用户将使用对象中的数据，从而导致许多读取操作。有时，我需要更新缓存对象中的一些次要数据点（创建和替换会花费太多时间）。

下面是我创建的一个缓存管理器类来帮助我。除了基本的线程安全之外，我的目标是：

  1. 允许对一个对象进行多次读取，但在更新请求时锁定对该对象的所有读取
  2. 如果对象不存在，请确保仅创建 1 次（请记住，这是一个漫长的构建操作）。

  3. 允许缓存存储许多对象，并为每个对象维护一个锁（而不是为所有对象一个锁）。

    public class CacheManager 
{
    private static readonly ObjectCache Cache = MemoryCache.Default;
    private static readonly ConcurrentDictionary<string, ReaderWriterLockSlim>
         Locks = new ConcurrentDictionary<string, ReaderWriterLockSlim>();
    private const int CacheLengthInHours = 1;

    public object AddOrGetExisting(string key, Func<object> factoryMethod)
    {
        Locks.GetOrAdd(key, new ReaderWriterLockSlim());

        var policy = new CacheItemPolicy 
          { 
             AbsoluteExpiration = DateTimeOffset.Now.AddHours(CacheLengthInHours)
          };
        return Cache.AddOrGetExisting
            (key, new Lazy<object>(factoryMethod), policy);
    }

    public object Get(string key)
    {
        var targetLock = AcquireLockObject(key);
        if (targetLock != null)
        {
            targetLock.EnterReadLock();

            try
            {
                var cacheItem = Cache.GetCacheItem(key);
                if(cacheItem!= null)
                    return cacheItem.Value;
            }
            finally 
            {
                targetLock.ExitReadLock();
            }
        }

        return null;
    }

    public void Update<T>(string key, Func<T, object> updateMethod)
    {
        var targetLock = AcquireLockObject(key);
        var targetItem = (Lazy<object>) Get(key);

        if (targetLock == null || key == null) return;
        targetLock.EnterWriteLock();

        try
        {
            updateMethod((T)targetItem.Value);
        }
        finally
        {
            targetLock.ExitWriteLock();
        }
    }

    private ReaderWriterLockSlim AcquireLockObject(string key)
    {
        return Locks.ContainsKey(key) ? Locks[key] : null;
    }
}

我是否在保持线程安全的同时实现了我的目标？你们都看到了实现我的目标的更好方法吗？

谢谢！

更新：所以这里的底线是我真的试图在一个领域做太多事情。出于某种原因，我确信在管理缓存的同一类中管理 Get / Update 操作是个好主意。在查看了 Groo 的解决方案并重新思考了这个问题之后，我能够进行大量的重构，从而消除了我面临的这个问题。

4

1 回答 1

1

好吧，我不认为这门课能满足你的需要。

允许对对象进行多次读取，但在更新请求时锁定所有读取

您可以将所有读取锁定到缓存管理器，但您不会将读取（或更新）锁定到实际缓存的实例。

如果对象不存在，请确保仅创建 1 次（请记住，这是一个漫长的构建操作）。

我不认为你确保了这一点。在将对象添加到字典时，您没有锁定任何内容（此外，您正在添加一个惰性构造函数，因此您甚至不知道何时实例化该对象）。

编辑：这部分成立，我唯一要改变的是让Getreturn a Lazy<object>. 在编写程序时，我忘记强制转换它并调用ToString返回值“未创建值”。

允许缓存存储许多对象，并为每个对象维护一个锁（而不是为所有对象一个锁）。

这与第 1 点相同：您正在锁定字典，而不是对对象的访问。你的update委托有一个奇怪的签名（它接受一个类型化的泛型参数，并返回一个object从未使用过的参数）。这意味着您实际上是在修改对象的属性，并且这些更改对于您的程序中持有对该对象的引用的任何部分都是立即可见的。

如何解决这个问题

如果您的对象是可变的（我认为它是可变的），则无法确保事务一致性，除非您的每个属性也获得每次读取访问的锁定。简化这一点的一种方法是使其不可变（这就是为什么这些在多线程中如此受欢迎）。

或者，您可以考虑将这个大对象分解成更小的部分并分别缓存每个部分，如果需要，使它们不可变。

[编辑] 添加了竞争条件示例：

class Program
{
    static void Main(string[] args)
    {
        CacheManager cache = new CacheManager();
        cache.AddOrGetExisting("item", () => new Test());

        // let one thread modify the item
        ThreadPool.QueueUserWorkItem(s =>
        {
            Thread.Sleep(250);
            cache.Update<Test>("item", i =>
            {
                i.First = "CHANGED";
                Thread.Sleep(500);
                i.Second = "CHANGED";

                return i;
            });
        });

        // let one thread just read the item and print it
        ThreadPool.QueueUserWorkItem(s =>
        {
            var item = ((Lazy<object>)cache.Get("item")).Value;
            Log(item.ToString());
            Thread.Sleep(500);
            Log(item.ToString());
        });

        Console.Read();
    }

    class Test
    {
        private string _first = "Initial value";
        public string First
        {
            get { return _first; }
            set { _first = value; Log("First", value); }
        }

        private string _second = "Initial value";
        public string Second
        {
            get { return _second; }
            set { _second = value; Log("Second", value); }
        }

        public override string ToString()
        {
            return string.Format("--> PRINTING: First: [{0}], Second: [{1}]", First, Second);
        }
    }

    private static void Log(string message)
    {
        Console.WriteLine("Thread {0}: {1}", Thread.CurrentThread.ManagedThreadId, message);
    }

    private static void Log(string property, string value)
    {
        Console.WriteLine("Thread {0}: {1} property was changed to [{2}]", Thread.CurrentThread.ManagedThreadId, property, value);
    }
}

应该发生这样的事情：

t = 0ms  : thread A gets the item and prints the initial value
t = 250ms: thread B modifies the first property
t = 500ms: thread A prints the INCONSISTENT value (only the first prop. changed)
t = 750ms: thread B modifies the second property
于 2012-11-08T20:56:48.843 回答