优雅的断言函数不是从多个线程调用的

Question

我有一个不能同时从多个线程调用的函数。你能为此提出一些优雅的断言吗？

Answer 1

您可以在std::atomic<> 周围使用薄的 RAII 包装器：

namespace {
    std::atomic<int> access_counter;

    struct access_checker {
        access_checker() { check = ++access_counter; }
        access_checker( const access_checker & ) = delete;
        ~access_checker() { --access_counter; }
        int check;
    };
}


void foobar()
{
     access_checker checker;
     // assert than checker.check == 1 and react accordingly
     ...
}

它是单一使用的简化版本，以展示想法，如果需要，可以改进以用于多种功能

Answer 2

听起来你需要一个互斥锁。假设您使用的是std::thread，您可以查看以下链接中的编码示例，以专门使用std::mutex：http://www.cplusplus.com/reference/mutex/mutex/

// mutex example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex

std::mutex mtx;           // mutex for critical section

void print_block (int n, char c) {
  // critical section (exclusive access to std::cout signaled by locking mtx):
  mtx.lock();
  for (int i=0; i<n; ++i) { std::cout << c; }
  std::cout << '\n';
  mtx.unlock();
}

int main ()
{
  std::thread th1 (print_block,50,'*');
  std::thread th2 (print_block,50,'$');

  th1.join();
  th2.join();

  return 0;
}

在上面的代码中print_block锁定mtx，做它需要做的，然后解锁mtx。如果从两个不同的线程调用print_block，一个线程将首先锁定mtx，另一个线程将阻塞mtx.lock()，并强制等待直到另一个线程调用mtx.unlock()。这意味着只有一个线程可以同时执行mtx.lock() 和mtx.unlock()（不包括）之间的代码。

这假设“同时”是指在同一时间。如果您只希望一个线程能够调用一个函数，我建议您查看std::this_thread::get_id，它将为您提供当前线程的 id。断言可以简单到将拥有的线程存储在owning_thread_id 中，然后调用assert(owning_thread_id == std::this_thread::get_id())。