这段代码还有什么比升压互斥锁更快的吗?

Is there anything Faster than a boost mutex for this code?

本文关键字：段代码 代码 什么      更新时间：2023-10-16

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

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::lock_guard<boost::recursive_mutex> lock(m_guard);

似乎每次调用methodA()时都会在堆栈上创建锁。我正在考虑将锁声明为静态变量，因此每次调用此方法时都不会在堆栈上创建锁。在这种情况下，我如何添加m_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::atomic_flag之上实现的自旋锁。

SO:什么时候应该使用自旋锁而不是互斥锁?

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
}

boost::lock_guard<boost::recursive_mutex> lock(m_guard);似乎每次调用methodA()时都会在堆栈上创建锁。

它不是锁，它只是RAII包装器，在构造函数中锁定互斥锁，在析构函数中释放互斥锁。在栈上创建lock_guard是可以的

相关文章：