2

我有一个具有 3-4 个类型的数据成员的类std::map<string, vector<string>>，用于缓存数据。它的实例被创建一次，并且数据被填充到来自服务调用的所有映射中。我有用于访问这些地图的 getter 函数。（这也有一些线程锁定逻辑）

这些 getter 函数被调用了很多次，我担心地图对象被复制很多次时的性能。

class A {
  private:
    map<string, vector<string>> m1;
    map<string, vector<string>> m2;
    map<string, vector<string>> m3;

  public:
    map<string, vector<string>> getm1() { return m1; }
    map<string, vector<string>> getm2() { return m2; } 
    map<string, vector<string>> getm3() { return m3; }
}

class B {
   B() { }
   static A a;

   map<string, vector<string>> getm1() { return a.m1; }
   map<string, vector<string>> getm2() { return a.m2; } 
   map<string, vector<string>> getm3() { return a.m3; } 
}

这些 getter 函数多次从 class 调用B。对 cpp 有中级知识，我知道 getter 会按值返回整个映射。但是，最好是通过引用传递它还是使用指向映射的共享指针（例如存储成员变量m1, m2）m3作为shared_ptr<map>

  shared_ptr<map<string, vector<string>>> getm1() { return a.m1; }

这不是性能问题，编译器会处理吗？

在阅读了一些关于返回值优化的内容并稍微理解之后，编译器可以处理一些优化。这是 RVO 的一部分吗？

先感谢您。

4

2 回答 2

9

将引用 ( &) 返回到const地图。

class A
{    
    using Map_type = std::map<std::string, std::vector<std::string>>;

    Map_type m1;
    Map_type m2;
    Map_type m3;

  public:
    const auto& getm1() const { return m1; }
    const auto& getm2() const { return m2; } 
    const auto& getm3() const { return m3; }
};

这将允许调用函数“只读”访问地图，而无需支付副本费用。

对于C++11及更低版本，auto必须在函数上声明返回类型，而不是作为返回类型。也using仅适用于 C++11 及更高版本，但typedef必须使用更早的编译器。

class A
{    
    typedef std::map<std::string, std::vector<std::string>> Map_type;

    Map_type m1;
    Map_type m2;
    Map_type m3;

  public:
    const Map_type& getm1() const { return m1; }
    const Map_type& getm2() const { return m2; } 
    const Map_type& getm3() const { return m3; }
};
于 2018-02-20T22:12:29.877 回答
1

如果您有内部锁定，那么您不能只返回对缓存地图的引用而不会导致竞争条件。您还需要为调用者提供一种锁定数据不被修改的方法。如果您正在寻找效率，那么要考虑的一种设计是这样的：

class Cache
{
public:
    using mutex_type   = std::shared_timed_mutex;
    using reading_lock = std::shared_lock<mutex_type>;
    using writing_lock = std::unique_lock<mutex_type>;

    using map_type = std::map<std::string, std::vector<std::string>>;

    reading_lock lock_for_reading() const { return reading_lock{mtx}; }
    writing_lock lock_for_writing()       { return writing_lock{mtx}; }

    map_type const& use() const { return m; }

private:

    void update_map()
    {
        // protect every update with a writing_lock
        auto lock = lock_for_writing();

        // safely update the cached map
        m["wibble"] = {"fee", "fie", "foe", "fum"};
    }

    mutable mutex_type mtx;
    map_type   m = {{"a", {"big", "wig"}}, {"b", {"fluffy", "bunny"}}};

};

int main()
{
    Cache cache;

    { // start a scope just for using the map

        // protect every access with a reading_lock
        auto lock = cache.lock_for_reading();

        // safely use the cached map
        for(auto const& s: cache.use().at("a"))
            std::cout << s << '\n';

    } // the lock is released here

    // ... etc ...
}

通过使调用者可以使用锁定，您可以让他们在读取数据时保护数据免受竞争条件的影响。通过同时使用读写锁，您可以获得性能，因为您知道调用者不会修改缓存的数据。

在内部，当您更新缓存的地图时，您需要使用writing_lock以确保在更新它们时没有其他人正在阅读它们。

为了提高效率，您可能需要mutex为每张地图单独使用，但这取决于您所处情况的具体动态。

注意：此解决方案让调用者负责正确锁定数据。这里建议了一个更强大（和复杂）的解决方案： GSL 的一个想法，通过这里的示例实现使多线程代码更安全： gsl_lockable。

于 2018-02-20T22:43:39.867 回答