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())一样简单。

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

2 个答案: