在 C++ 中缓存昂贵的数据 - 函数范围的静态与可变成员变量

Question

我有一个相对昂贵的数据获取操作，我想缓存其结果。 此操作是从 const 方法调用的，大致如下：

double AdjustData(double d, int key) const {
  double factor = LongRunningOperationToFetchFactor(key);
  return factor * d;
}

我希望 AdjustData 保持 const，但我想缓存该因子所以我只在第一次获取它。 目前我正在使用 mutable map 来存储结果（该映射是从 key 到 factor），但是我认为使用函数范围的静态可能是一个更好的解决方案 - 这个因素仅由该函数需要，并且与类的其余部分无关。

这看起来是个好方法吗？ 还有更好的选择吗？ 我可能会考虑哪些事情，特别是在线程安全方面。

谢谢，

多姆

Answer 1

我会用这样的东西包装 LongRunningOperationToFetchFactor 的实现。 我正在使用 Boost 作用域锁，但您也可以使用其他锁定框架进行类似的操作。

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <map>

using namespace std;

static boost::mutex myMutex;
static map<int,double> results;

double CachedLongRunningOperationToFetchFactor( int key )
{

   {
       boost::mutex::scoped_lock lock(myMutex);

       map<int,double>::iterator iter = results.find(key);
       if ( iter != results.end() )
       {
          return (*iter).second;
       }
   }
   // not in the Cache calculate it
   result = LongRunningOperationToFetchFactor( key );
   {
       // we need to lock the map again
       boost::mutex::scoped_lock lock(myMutex);
       // it could be that another thread already calculated the result but
       // map assignment does not care.
       results[key] = result;
   }
   return result;
}

如果这确实是一个长时间运行的操作，那么锁定互斥体的成本应该是最小的。

您的问题不太清楚，但如果函数 LongRunningOperationToFetchFactor 是您类的成员函数，那么您希望该映射在同一类中成为可变映射。 不过，我使用单个静态互斥体进行访问仍然足够快。

Answer 2

我不会将此缓存设为本地静态。 可变映射是缓存结果的解决方案。 否则，它将使您的函数毫无用处，因为您的类的不同对象将共享相同的缓存，因为所有对象的本地静态缓存都是相同的。 如果结果不依赖于对象，您可以使用局部静态。 但后来我会问自己，如果该函数不需要访问对象的任何状态，为什么它是对象的非静态成员。

正如您所说，它应该是线程安全的 - 如果不同的线程可以调用同一对象上的成员函数，您可能需要使用互斥体。 boost::thread 是一个很好用的库。

Answer 3

您可以使用单例模式(1) 来执行长时间运行的操作的类并缓存结果。 然后可以在其他类的 const 成员函数中使用该实例。 考虑互斥来保护映射数据结构的插入和提取，从而保证线程安全。 如果多线程性能是一个大问题，那么您可以将密钥标记为正在进行中，以防止多个线程同时计算同一密钥。

#include <cstdlib>
#include <iostream>
#include <map>

using namespace std;

class FactorMaker {
    map<int, double> cache;

    double longRunningFetch(int key)
    {
        const double factor = static_cast<double> (rand()) / RAND_MAX;
        cout << "calculating factor for key " << key << endl;
        // lock
        cache.insert(make_pair(key, factor));
        // unlock
        return factor;
    }

public:
    double getFactor(int key) {
        // lock
        map<int, double>::iterator it = cache.find(key);
        // unlock
        return (cache.end() == it) ? longRunningFetch(key) : it->second;
    }
};

FactorMaker & getFactorMaker()
{
    static FactorMaker instance;
    return instance;
}

class UsesFactors {
public:
    UsesFactors() {}

    void printFactor(int key) const
    {
        cout << getFactorMaker().getFactor(key) << endl;
    }
};

int main(int argc, char *argv[])
{
    const UsesFactors obj;

    for (int i = 0; i < 10; ++i)
        obj.printFactor(i);

    for (int i = 0; i < 10; ++i)
        obj.printFactor(i);

    return EXIT_SUCCESS;
}

(1) 单例模式可能会被严重忽略。 所以，如果您是第一次看到它，请不要为它疯狂。

Answer 4

除非我不明白，否则对我来说很明显你想将其设为静态：

double AdjustData(double d) const {
   static const double kAdjustFactor = LongRunningOperationToFetchFactor();
   return kAdjustFactor * d;
}

这样你只获取一次因子。