C++ 对于这段代码，还有比boost互斥更快的吗？

目前在我的代码中，我有这样的部分

boost::mutex Mymutex

void methodA()
{
   boost::mutex::scoped_lock lock(Mymutex);
   ......
   ......
   ......
}

我读到临界区比互斥区快？所以我在做类似的事情，我想知道这是否更快

 boost::recursive_mutex m_guard;
 void methodA()
 {
       // this section is not locked
      {
          boost::lock_guard<boost::recursive_mutex> lock(m_guard);
         // this section is locked
      }
      //This section not locked
 }    

boost:：递归互斥m\u保护；
void methodA（）
{
//此分区未锁定
{
boost：：lock_guard lock（m_guard）；
//这部分是锁着的
}
//此分区未锁定
}    

第二种方法更快吗？我主要使用互斥的原因是为了防止竞争条件，并锁定对方法的访问，以便一个线程一次访问它。还有比这更快的吗？我的另一个关注点是这份声明

  boost::lock_guard<boost::recursive_mutex> lock(m_guard);

boost:：lock\u-guard锁（m\u-guard）；

似乎每次调用methodA（）时，都会在堆栈上创建锁。 我在考虑将lock声明为一个静态变量，这样它就不会在每次调用这个方法时都在堆栈上创建。在这种情况下，我如何向它添加mu-guard呢。比如说

 boost::recursive_mutex SomeClass::m_guard; //This is static 
 boost::lock_guard<boost::recursive_mutex> SomeClass::lock //Suppose this is static
 void SomeClass::methodA()
 {

      {
         //How do i make lock "lock" mguard 

      }

 }    

boost:：recursive\u mutex SomeClass:：m\u guard//这是静态的
boost:：lock\u guard SomeClass:：lock//假设这是静态的
void SomeClass:：methodA（）
{
{
//如何制作锁“锁”mguard
}
}    

还有比这更快的吗

如果适合您的情况，您可以尝试在

boost:：atomic_标志

上使用implemented

所以：

类自旋锁
{
原子_标志=原子_标志_初始；
公众：
无效锁（）
{
while（flag.test_和_set（memory_order_acquire））；
}
无效解锁（）
{
清除标志（存储器、命令和释放）；
}
};
void foo（）
{
静态自旋锁；
锁紧护板（锁紧）；
//干
}

boost:：lock\u-guard锁（m\u-guard）似乎每次调用methodA（）时，都会在堆栈上创建锁

它不是锁，只是RAII包装器，它在构造函数中锁定互斥体，在析构函数中释放互斥体。在堆栈上创建锁保护是可以的。
我从来没有机会使用原子标志。
atomic.hpp
？
class spinlock
{
    atomic_flag flag = ATOMIC_FLAG_INIT;
public:
    void lock()
    {
        while(flag.test_and_set(memory_order_acquire));
    }
    void unlock()
    {
        flag.clear(memory_order_release);
    }
};

void foo()
{
    static spinlock lock;
    lock_guard<spinlock> guard(lock);
    // do job
}