Question

让我们以Wes Dyer's方法将函数memoization作为起点：

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

问题是，当从多个线程使用它时，我们可能会遇到麻烦：

Func<int, int> f = ...
var f1 = f.Memoize();
...
in thread 1:
var y1 = f1(1);
in thread 2:
var y2 = f1(1);
// We may be recalculating f(1) here!

让我们试着避免这种情况。锁定map：

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

显然是一个可怕的想法，因为它阻止我们一次在许多不同的参数上计算f1。如果a具有值类型，那么锁定a将无效（并且无论如何都是一个坏主意，因为我们无法控制a并且外部代码可能锁定它，太）。

以下是我能想到的两个选项：

假设一个Lazy<T>类用于延迟评估（参见here）：

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

或保留对象的附加词典以进行同步：

public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
{
  var map = new Dictionary<A, R>();
  var mapSync = new Dictionary<A, object>();
  return a =>
    {
      R value;
      object sync;
      lock(mapSync)
      { 
        if (!mapSync.TryGetValue(a, out sync))
        { 
          sync = new object();
          mapSync[a] = sync;
        }
      }
      lock(map)
      {
        if (map.TryGetValue(a, out value))
          return value;
      }
      lock(sync)
      {
        value = f(a);
        lock(map)
        {
          map[a] = value;
        }
        return value;
      }
    };
}

有更好的选择吗？

Answer 1

使用.net 4.0的ConcurrentDictionary<A, R>，而不必使用Lazy<R> 关键是GetOrAdd(A, Func<A, R>)，它变成了一个非常琐碎的lambda。

public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
{
    var cache = new ConcurrentDictionary<A, R>();
    return a => cache.GetOrAdd(a, f);
};

更新以上解决方案确实允许多个同时阅读器和编写者的开销最小。但是，它不会阻止f(a)对同一个值执行多次（在计算期间）。

如果这对您至关重要，您可以将值包装在Lazy<R>中，但每次阅读都会产生费用。

public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
{
    var cache = new ConcurrentDictionary<A, Lazy<R>>();
    return a => cache.GetOrAdd(a, new Lazy<R>(() => f(a))).Value;
}

更新预先填充的1000项缓存的百万次读取的时间测试显示ConcurrentDictionary 19ms - 与常规{{1}相同} - 但 720ms 适用于Dictionary版本。

如果这听起来太陡，你可以用更复杂的解决方案来获得两全其美。

Lazy

Answer 2

如果您已经拥有Lazy<T>类型，我认为您使用的是.net 4.0，因此您也可以使用ConcurrentDictionary<A,R>：

public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
{
  var map = new ConcurrentDictionary<A, Lazy<R>>();
  return a =>
    {
      Lazy<R> lazy = new Lazy<R>(() => f(a), LazyExecutionMode.EnsureSingleThreadSafeExecution);
      if(!map.TryAdd(a, lazy))
      {
        return map[a].Value;
      }
      return lazy.Value;
    };
}

Answer 3

由于Lazy构造函数的enum参数，Thomas的答案似乎不能在.NET 4.0下编译。我在下面修改了它。我还添加了一个可选参数，用于提供自己的相等比较器。如果TInput没有实现自己的Equals，或者TInput是一个字符串，并且你想让它不区分大小写，那么这很有用。

    public static Func<TInput, TResult> Memoize<TInput, TResult>(
        this Func<TInput, TResult> func, IEqualityComparer<TInput> comparer = null)
    {
        var map = comparer == null
                      ? new ConcurrentDictionary<TInput, Lazy<TResult>>()
                      : new ConcurrentDictionary<TInput, Lazy<TResult>>(comparer);

        return input =>
               {
                   var lazy = new Lazy<TResult>(() => func(input), LazyThreadSafetyMode.ExecutionAndPublication);

                   return map.TryAdd(input, lazy)
                              ? lazy.Value
                              : map[input].Value;
               };
    }

我使用这个作为我的测试做了一些基本的测试方法：

    public void TestMemoize()
    {
        Func<int, string> mainFunc = i =>
                                     {
                                         Console.WriteLine("Evaluating " + i);
                                         Thread.Sleep(1000);
                                         return i.ToString();
                                     };

        var memoized = mainFunc.Memoize();

        Parallel.ForEach(
            Enumerable.Range(0, 10),
            i => Parallel.ForEach(Enumerable.Range(0, 10), j => Console.WriteLine(memoized(i))));
    }

它似乎工作正常。

Answer 4

扩展Nigel Touch的优秀的答案，我想提供一个从他的解决方案中提取的可重用组件，限制f（a）的调用次数。

我称它为SynchronizedConcurrentDictionary，它看起来像这样：

public class SynchronizedConcurrentDictionary<TKey, TValue> : ConcurrentDictionary<TKey, TValue>
{
    private readonly ReaderWriterLockSlim _cacheLock = new ReaderWriterLockSlim();

    public new TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
    {
        TValue result;

        _cacheLock.EnterWriteLock();
        try
        {
            result = base.GetOrAdd(key, valueFactory);
        }
        finally
        {
            _cacheLock.ExitWriteLock();
        }

        return result;
    }
}

然后Memoize功能变成了两行：

public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
{
    var cache = new SynchronizedConcurrentDictionary<A, R>();

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

干杯！

Answer 5

不，他们不是更好的选择。

具有懒惰评估的版本毫无意义，因为您无论如何都会立即评估它。带有同步字典的版本无法正常工作，因为在使用之前您没有保护锁内的地图字典。

你称之为可怕的版本实际上是最好的选择。您必须保护锁内的地图字典，以便一次只能有一个线程访问它。字典不是线程安全的，所以如果你让一个线程从中读取而另一个线程正在改变它，你就会遇到问题。

请记住，在地图对象上使用锁不会保护地图对象本身，它只使用地图引用作为标识符来一次保留多个线程来运行锁内的代码。您必须将访问对象的所有代码放在锁内，而不仅仅是更改对象的代码。

Answer 6

您不希望两次计算相同的值，并且您希望许多线程能够同时计算值和/或检索值。为此，您需要使用某种条件变量和细粒度锁定系统。

继承人的想法。当没有值存在时，你将一个值放入同步映射，然后任何需要该值的线程将等待它，否则你将只获取当前值。这样就可以最小化地图的锁定，以查询值和返回值。

    public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
    {
        var map = new Dictionary<A, R>();
        var mapSync = new Dictionary<A, object>();
        return a =>
        {
            R value;
            object sync = null;
            bool calc = false;
            bool wait = false;
            lock (map)
            {
                if (!map.TryGetValue(a, out value))
                {
                    //its not in the map
                    if (!mapSync.TryGetValue(a, out sync))
                    {
                        //not currently being created
                        sync = new object();
                        mapSync[a] = sync;
                        calc = true;

                    }
                    else
                    {
                        calc = false;
                        wait = true;
                    }
                }
            }
            if(calc)
            {
                lock (sync)
                {
                    value = f(a);
                    lock (map)
                    {
                        map.Add(a, value);
                        mapSync.Remove(a);
                    }
                    Monitor.PulseAll(sync);
                    return value;
                }
            }
            else if (wait)
            {
                lock (sync)
                {
                    while (!map.TryGetValue(a, out value))
                    {
                        Monitor.Wait(sync);
                    }
                    return value;
                }
            }

            lock (map)
            {
                return map[a];
            }

        };
    }

这只是一个快速的第一次尝试，但我认为它演示了这项技术。在这里，你要为速度交换额外的内存。

Answer 7

您是否在文章中阅读了与线程安全相关的comment from Dyer？

使Memoize线程安全的最简单方法可能是锁定地图。

这将确保正在被记忆的函数只为每组不同的参数运行一次。

在我的RoboRally游戏的例子中，我实际上使用了函数记忆来充当“代理单身人士”。它实际上不是单例，因为每个工厂实例可以有一个实例（除非工厂是静态的）。但这正是我想要的。

线程安全的memoization

7 个答案: