如何以自然的语法实现线程安全容器？

Preface

如果按原样使用，下面的代码会导致未定义的行为：

vector<int> vi;
...
vi.push_back(1);  // thread-1
...
vi.pop(); // thread-2

传统的方法是修复它std::mutex:

std::lock_guard<std::mutex> lock(some_mutex_specifically_for_vi);
vi.push_back(1);

然而，随着代码的增长，这样的事情开始看起来很麻烦，因为每次方法之前都会有一个锁。此外，对于每个对象，我们可能必须维护一个互斥体。

客观的

在不影响访问对象和声明显式互斥体的语法的情况下，我想创建一个模板，以便它完成所有样板工作。例如

Concurrent<vector<int>> vi;  // specific `vi` mutex is auto declared in this wrapper
...
vi.push_back(1); // thread-1: locks `vi` only until `push_back()` is performed
...
vi.pop ()  // thread-2: locks `vi` only until `pop()` is performed

在当前的C++中，这是不可能实现的。但是，我尝试了一个代码，如果只是改变vi. to vi->，那么事情就会按上面代码注释中的预期工作。

Code

// The `Class` member is accessed via `->` instead of `.` operator
// For `const` object, it's assumed only for read purpose; hence no mutex lock
template<class Class,
         class Mutex = std::mutex>
class Concurrent : private Class
{
  public: using Class::Class;

  private: class Safe
           {
             public: Safe (Concurrent* const this_,
                           Mutex& rMutex) :
                     m_This(this_),
                     m_rMutex(rMutex)
                     { m_rMutex.lock(); }
             public: ~Safe () { m_rMutex.unlock(); }

             public: Class* operator-> () { return m_This; }
             public: const Class* operator-> () const { return m_This; }
             public: Class& operator* () { return *m_This; }
             public: const Class& operator* () const { return *m_This; }

             private: Concurrent* const m_This;
             private: Mutex& m_rMutex;
           };

  public: Safe ScopeLocked () { return Safe(this, m_Mutex); }
  public: const Class* Unsafe () const { return this; }

  public: Safe operator-> () { return ScopeLocked(); }
  public: const Class* operator-> () const { return this; }
  public: const Class& operator* () const { return *this; }

  private: Mutex m_Mutex;
};

Demo https://ideone.com/UEhusW

问题

• 正在使用临时对象来调用重载函数operator->()导致 C++ 中未定义的行为？
• 这个小实用程序类是否为封装对象提供线程安全的目的在所有情况下?

澄清

对于相互依赖的语句，需要更长的锁定。于是，就有了一个方法介绍：ScopeLocked()。这相当于std::lock_guard()。然而，给定对象的互斥锁是在内部维护的，因此在语法上它仍然更好。
例如而不是以下有缺陷的设计（如答案中所建议的）：

if(vi->size() > 0)
  i = vi->front(); // Bad: `vi` can change after `size()` & before `front()`

应该依赖以下设计：

auto viLocked = vi.ScopeLocked();
if(viLocked->size() > 0)
  i = viLocked->front();  // OK; `vi` is locked till the scope of `viLocked`

换句话说，对于相互依赖的陈述，应该使用ScopeLocked().

不要这样做。

创建一个每个方法都带有锁的线程安全集合类几乎是不可能的。

考虑您建议的 Concurrent 类的以下实例。

Concurrent<vector<int>> vi;

开发人员可能会这样做：

 int result = 0;
 if (vi.size() > 0)
 {
     result = vi.at(0);
 }

另一个线程可能会在第一个线程调用之间进行此更改size() and at(0).

vi.clear();

所以现在，同步操作顺序是：

vi.size()  // returns 1
vi.clear() // sets the vector's size back to zero
vi.at(0)   // throws exception since size is zero

因此，即使您有一个线程安全的向量类，两个竞争线程也可能导致在意外的地方抛出异常。

这只是最简单的例子。还有其他一些方式，多个线程尝试同时读/写/迭代可能会无意中破坏线程安全的保证。

您提到整个事情的动机是这种模式很麻烦：

vi_mutex.lock();
vi.push_back(1);
vi_mutex.unlock();

事实上，有一些帮助器类可以使这个更干净，即lock_guard，它将使用互斥锁来锁定其构造函数并在析构函数上解锁

{
    lock_guard<mutex> lck(vi_mutex);
    vi.push_back(1);
}

那么实践中的其他代码就变得线程安全了：

{
     lock_guard<mutex> lck(vi_mutex);
     result = 0;
     if (vi.size() > 0)
     {
         result = vi.at(0);
     }
}

Update:

我编写了一个示例程序，使用您的 Concurrent 类来演示导致问题的竞争条件。这是代码：

Concurrent<list<int>> g_list;

void thread1()
{
    while (true)
    {
        if (g_list->size() > 0)
        {
            int value = g_list->front();
            cout << value << endl;
        }
    }

}

void thread2()
{
    int i = 0;
    while (true)
    {
        if (i % 2)
        {
            g_list->push_back(i);
        }
        else
        {
            g_list->clear();
        }
        i++;
    }
}

int main()
{

    std::thread t1(thread1);
    std::thread t2(thread2);

    t1.join(); // run forever

    return 0;
}

在非优化的构建中，上面的程序会在几秒钟内崩溃。 （零售有点困难，但错误仍然存​​在）。