有序非重入调用的简单断言？

Question

我有两个函数：

void prepare() 和 void finish() ，它们将按顺序调用，如下所示：

prepare();
<do something>;
finish(); 
... 
prepare(); 
<do something>; 
finish();

我想做一个简单的断言来简单地测试它们实际上是这样调用的，并且它们不是同时调用的应用程序中无序。

该应用程序是单线程应用程序。这是一个简单的开发/测试健全性检查，以确保这些函数按顺序调用，并且无论出于何种原因，它们都不会同时调用。此外，这些断言/健全性检查应该从生产代码中省略，因为性能至关重要！

像这样的简单的assert()效果最好吗？

int test = 0;

void prepare() {
   assert(++test == 1);

   .
   .
   .
}

void finish() {
    assert(--test == 0);

    .
    .
    .
}

Answer 1

您可能希望更改

int test = 0;

为

#ifndef NDEBUG
int test = 0;
#endif

满足“应从生产中省略与此测试相关的任何代码”的要求。

Answer 2

你可能想要：

int test = 0;

void prepare() {
    // enter critical section
    assert(test++ == 0);

    .
    .
    .
    // leave critical section 
}

void finish() {
    // enter critical section
    assert(--test == 0);

    .
    .
    .
    // leave critical section
}

Answer 3

这里存在一个竞争条件：prepare 的两个并发实例可能会同时获取 test 的值，然后都在寄存器中递增该值以获得 1，然后进行比较以获得true。

使其易失是

boost::mutex mtx;
int test = 0;

void prepare()
{
    boost::mutex::scoped_try_lock lock(&mtx);
    assert(lock.owns_lock());
    assert(test++ == 0);
    // ...
}

void finish()
{
    boost::mutex::scoped_try_lock lock(&mtx);
    assert(lock.owns_lock());
    assert(--test == 0);
}

Answer 4

您的代码没问题，除非您需要允许嵌套 prepare 和 finish 调用。

如果不允许嵌套，您可以使用 bool 代替 int：

bool locked = false;;

void prepare() {
    assert( ! locked );
    locked = true;
    ...
}

void finish() {
    assert( locked );
    locked = false;
    ...
}

Answer 5

如果将 >; 放入 class 中，则可以完全减少检查的需要：

只需让构造函数调用 prepare析构函数调用finish。然后它会自动强制正确调用它们。

请注意，并发和嵌套问题仍然适用：如果您想防止嵌套，那么您仍然需要某种全局状态（静态类成员？）来跟踪它，并且如果它用于多个线程访问该状态计数器需要受到互斥保护。

另请注意，您还可以将运算符设为私有 new/delete ，以防止有人在堆上创建一个运算符而不销毁它。

Answer 6

既然您使用的是 C++，为什么不使用 RAII？您仍然需要检查可重入使用，但 RAII 大大简化了事情。与 NDEBUG 中的 larsmans' mutex 和 Raedwald 消除相结合：

struct Frobber {
  Frobber() {
    assert(mtx.try_lock());
#ifndef NDEBUG
    try {  // in case prepare throws
#endif
      prepare();
#ifndef NDEBUG
    }
    catch (...) {
      mtx.unlock();
      throw;
    }
#endif
  }

  void something();
  // And the other actions that can be performed between preparation and finishing.

  ~Frobber() {
    finish();
#ifndef NDEBUG
    mtx.unlock();
#endif
  }

private:
#ifndef NDEBUG
  static boost::mutex mtx;
#endif

  Frobber(Frobber const&);  // not defined; 0x: = delete
  Frobber& operator=(Frobber const&);  // not defined; 0x: = delete
};
#ifndef NDEBUG
boost::mutex Frobber::mtx;
#endif

void example() {
  Frobber blah;  // instead of prepare()
  blah.something();
  // implicit finish()
}

在示例中，如果没有先准备，您就无法执行某些操作，并且即使抛出异常，也总是会完成。

关于 NDEBUG 的旁注：如果您以这种方式使用它，请确保它在所有翻译单元中始终定义或始终未定义，而不是它用于断言的方式（允许定义和未定义）在不同的点）。