【问题标题】:How to thread-safe function that adds elements to array?如何将元素添加到数组的线程安全函数?
【发布时间】:2020-11-02 15:26:03
【问题描述】:

我编写了以下函数,它接受一个对象 (element),在现有向量 (elements) 中为它腾出空间,并通过添加新对象来更新向量:

void addElement(const ElementType& element) {
    if (numElements == elements.size()) {
        elements.resize(boost::extents[numElements+1]);
    }

    elements[numElements] = element;

    numElements++;
}

我怎样才能使它对 MPI 线程安全?据我了解,每个线程都知道elements 的大小,因此我不明白为什么这个函数不是线程安全的。 numElements 在这个函数之外被初始化为零并且是elements 向量的大小。

编辑:我正在使用上面写的函数和 mtx 锁定和解锁如下,但最终的elements 向量仍然只包含第一级的数据。

    #pragma omp parallel for collapse(3) schedule(static)
    for (long n0 = mgr->startN0; n0 < mgr->startN0 + mgr->localN0; n0++) {
      for (int n1 = 0; n1 < Ν; n1++) {
        for (int n2 = 0; n2 < Ν; n2++) {
          ElementType element;
          std::mutex mtx;
            for(int i=0;i<g_field[n0][n1][n2];i++){
              ... do stuff with element ...
              mtx.lock();
              #pragma omp critical
              addElement(element);
              mtx.unlock();}
       }
     }
   }

编辑:出于速度原因,我不得不稍微更改功能及其用途:

void addElements_MPI(std::vector<ElementType> new_batch,std::mutex& mtx) {

  std::lock_guard<std::mutex> lock(mtx); 
  elements.resize(boost::extents[elements.num_elements()+new_batch.size()]); 

  std::copy(new_batch.begin(), new_batch.end(), elements.begin()+numElements); 

  numElements += new_batch.size();
}
std::mutex mtx;
std::vector<ElementType> all_elements;
#pragma omp parallel for collapse(3) schedule(static)
    for (long n0 = mgr->startN0; n0 < mgr->startN0 + mgr->localN0; n0++) {
      for (int n1 = 0; n1 < Ν; n1++) {
        for (int n2 = 0; n2 < Ν; n2++) {

          ElementType element;

            for(int i=0;i<g_field[n0][n1][n2];i++){
              ... do stuff with element ...
              mtx.lock();
              #pragma omp critical
              all_elements.push_back(element);
              mtx.unlock();}
       }
     }
   }
 mtx.lock();
 #pragma omp critical
 addElement_MPI(all_elements,mtx);
 mtx.unlock();

【问题讨论】:

  • 2 个(或更多)线程可以同时addElement。为了保护这一点,您需要使用std::mutex
  • MPI和线程安全有什么联系?

标签: c++ multithreading c++11 thread-safety stdthread


【解决方案1】:

首先,让我们看看数据竞争何时发生:

  • 两个或多个线程同时访问同一内存位置
  • 至少有一个访问是用于写入
  • 线程没有使用任何独占锁来控制它们对该内存的访问

在您的情况下,一个线程可以添加元素,而另一个线程正在读取elements。此外,多个线程可以同时添加新元素。要控制他们的访问,您应该锁定共享资源,即elements。

如何在 C++ 中锁定共享资源?

在 C++ 中,您可以使用std::mutex 来保护共享数据不被多个线程同时访问。当std::mutex被一个线程锁定时,其他线程无法访问共享资源。一旦std::mutex 被解锁,其他线程就可以访问该资源。您可以使用std::mutex::lock 和std::mutex::unlock 之类的:

std::mutex mtx;
ElementsType elements;

...
mtx.lock();

// only one thread accesses this part at a time
// work with elements

mtx.unlock();

开发人员经常忘记一些东西......

由于开发人员经常忘记一些东西...比如解锁被锁定的std::mutex...C++ 提供std::lock_guard(在 C++11 的情况下)和std::scoped_lock(在 C++17 的情况下) .您可以将std::lock_guard 和std::scoped_lock 视为某种包装器,它们将std::mutex 实例作为构造函数的参数并将std::mutex 实例锁定在构造函数中。当std::lock_guard或std::scoped_lock实例被破坏时,std::mutex实例自动解锁。

void addElement(const ElementType& element) {
    std::lock_guard<std::mutex> lock(mtx); // similar to mtx.lock()

    if (numElements == elements.size()) {
        elements.resize(boost::extents[numElements+1]);
    }

    elements[numElements] = element;

    numElements++;

    // no need for mtx.unlock() since lock instance is now destructed and mutex is automatically unlocked
}

编辑

由于std::mutex 是所有线程之间的某种通信通道,所有线程应该共享同一个std::mutex 实例,即同一个std::mutex 实例应该对所有线程可见。

以下情况(我从更新的问题中获取):

for (int n2 = 0; n2 < Ν; n2++) {
    ElementType element;
    std::mutex mtx;
    for(int i=0;i<g_field[n0][n1][n2];i++){
         // ... do stuff with element ...
         mtx.lock();
         #pragma omp critical
         addElement(element);
         mtx.unlock();}
    }
}

std::mutex 被创建 N 次,每个线程创建自己的 std::mutex 实例,这没有任何意义,因为它们无法相互通信。相反,一个std::mutex 实例应该对所有线程可见,就像elements 对所有线程可见一样。

【讨论】:

  • (赞成)但我认为对何时数据竞争发生以及std::lock_guard和std::scoped_lock的答案有一些解释。
  • @Kerek 谢谢,我会用这些建议更新我的答案
  • 感谢您非常详细的回答,非常感谢。我尝试使用锁定和解锁,但最终向量仍然包含来自第一级的数据。我已经相应地修改了我最初的问题,以防有人有时间查看它。
  • @Choumbie 你错过了一件事......你在函数本身中定义了std::mutex,所以每个线程都有自己的std::mutex,但所有线程应该共享相同的std::mutex,因为它是一些一种所有线程之间的通信通道。我建议你定义全局std::mutex实例对所有线程可见,它可以在定义elements的地方定义。
  • @NutCracker 我在你的博客上找到了你的电子邮件。给你发了一条消息!
猜你喜欢
  • 2018-09-12
  • 1970-01-01
  • 2010-10-19
  • 1970-01-01
  • 2015-05-11
  • 1970-01-01
  • 2019-04-08
  • 2014-05-26
  • 2015-05-14
相关资源
最近更新 更多