在这种情况下，'双重检查锁定模式'是否适合std :: mutex？

Question

I often encounter with the design of this thread-safe structure. As the following version1 , one thread may call foo1::add_data() rarely, and another thread often call foo1::get_result() . For the purpose of optimization, I think it can use an atomic for applying double checked locking pattern(DCLP), as version2 showed. Is there other better design for this situation? Or could it been improved, for example accessing atomic with std::memory_order ?

version1 :

class data {};
class some_data {};
class some_result {};

class foo1
{
public:
    foo1() : m_bNeedUpdate(false) {}

    void add_data(data n)
    {
        std::lock_guard<std::mutex> lock(m_mut);

        // ... restore new data to m_SomeData

        m_bNeedUpdate = true;
    }

    some_result get_result() const
    {
        {
            std::lock_guard<std::mutex> lock(m_mut);
            if (m_bNeedUpdate)
            {
                // ... process mSomeData and update m_SomeResult

                m_bNeedUpdate = false;
            }
        }
        return m_SomeResult;
    }

private:
    mutable std::mutex  m_mut;
    mutable bool        m_bNeedUpdate;
    some_data           m_SomeData;

    mutable some_result m_SomeResult;
};

version2 :

class foo2
{
public:
    foo2() : m_bNeedUpdate(false) {}

    void add_data(data n)
    {
        std::lock_guard<std::mutex> lock(m_mut);

        // ... restore new data to m_SomeData

        m_bNeedUpdate.store(true);
    }

    some_result get_result() const
    {
        if (m_bNeedUpdate.load())
        {
            std::lock_guard<std::mutex> lock(m_mut);
            if (m_bNeedUpdate.load())
            {
                // ... process mSomeData and update m_SomeResult

                m_bNeedUpdate.store(false);
            }
        }
        return m_SomeResult;
    }

private:
    mutable std::mutex          m_mut;
    mutable std::atomic<bool>   m_bNeedUpdate;
    some_data                   m_SomeData;

    mutable some_result         m_SomeResult;
};

Answer 1

The problem is that version 2 isn't thread safe, at least according to C++11 (and Posix, earlier); you're accessing a variable which may be modified without the access being protected. (The double checked locking pattern is known to be broken, see http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf .) It can be made to work in C++11 (or non-portably earlier) by using atomic variables, but what you've written results in undefined behavior.

Answer 2

I think a significant improvement (in terms of code size as well as in terms of simplicity and performance) could be achieved by using a 'read-write lock' which allows many threads to read in parallel. Boost provides shared_mutex for this purpose, but from a quick glance it appears that this blog article implements the same kind of lock in a portable manner without requiring Boost.

Answer 3

You said that you're calling get_average quite often, have you considered calculating average only based on numbers that you haven't 'seen'? It would be O(n) instead of O(n^2).

It would be something like

average = (last_average * last_size + static_cast<double>(
           std::accumulate(m_vecData.begin() + last_size, m_vecData.end(), 0))) /
           m_vecData.size();

It should give you satisfying results, depending on how big your vector is.