如何在c＃中执行线程安全的函数memoization？

Question

这里的堆栈溢出我已经found是memoizes单参数的函数代码：

static Func<A, R> Memoize<A, R>(this Func<A, R> f) 
{ 
    var d = new Dictionary<A, R>(); 
    return a=> 
    { 
     R r; 
     if (!d.TryGetValue(a, out r)) 
     { 
      r = f(a); 
      d.Add(a, r); 
     } 
     return r; 
    }; 
} 

尽管此代码，它的工作对我来说，它有时会失败时memoized功能同时从多个线程调用： Add方法被相同的参数调用两次并抛出异常。

我怎样才能让记忆化线程安全的？

Answer 1

您可以使用ConcurrentDictionary.GetOrAdd它做你需要的一切：

static Func<A, R> ThreadsafeMemoize<A, R>(this Func<A, R> f) 
{ 
    var cache = new ConcurrentDictionary<A, R>(); 

    return argument => cache.GetOrAdd(argument, f); 
} 

功能f应该是线程安全的本身，因为它可以从多个线程同时调用。

此代码还不能保证功能f称为每次唯一参数值只有一次。事实上，在繁忙的环境中，它可以被多次调用。如果你需要这种合同，你应该看看这个related question的答案，但要注意的是它们不是很紧凑，需要使用锁。

Answer 2

像Gman提到的ConcurrentDictionary是这样做的首选方法，但是如果不提供简单的lock语句就足够了。

static Func<A, R> Memoize<A, R>(this Func<A, R> f) 
{ 
    var d = new Dictionary<A, R>(); 
    return a=> 
    { 
     R r; 
     lock(d) 
     { 
      if (!d.TryGetValue(a, out r)) 
      { 
       r = f(a); 
       d.Add(a, r); 
      } 
     } 
     return r; 
    }; 
} 

一个潜在的问题，使用锁代替ConcurrentDictionary是这个方法在你的程序导致死锁。

1. 你有两个memoized功能_memo1 = Func1.Memoize()和_memo2 = Func2.Memoize()，其中_memo1和_memo2是实例变量。
2. 线程1调用_memo1，Func1开始处理。
3. 线程2调用_memo2，内部Func2有一个_memo1和Thread2块的调用。
4. 的Func1线程1的处理获取到的_memo2呼叫尾盘功能，线程1块。
5. 死锁！

因此，如果可能的话，使用ConcurrentDictionary，但如果你不能和你使用的锁，而不是不调用的作用域的功能之外，你在里面的时候Memoized功能运行或打开其他Memoized功能自己最多死锁的风险（如果_memo1和_memo2了局部变量而不是实例变量的僵局就不会发生）。

System.Collections中使用（注意，性能可能会稍微用ReaderWriterLock改善，但你仍然有相同的僵局问题。）

Answer 3

。通用;

Dictionary<string, string> _description = new Dictionary<string, string>(); 
public float getDescription(string value) 
{ 
    string lookup; 
    if (_description.TryGetValue (id, out lookup)) { 
     return lookup; 
    } 

    _description[id] = value; 
    return lookup; 
}