c++ - 编译器怎么知道不从锁定/解锁内部优化语句？在 C++ 中使用 boost::spinlocks

Question

具有两个重载 operator() 函数的类从不同的线程调用。请参阅下面代码中的//注释。

优化器是否知道不要将 entryadd = mSpread * ENTRY_MULTIPLIER 移动到 lock() 之上？

struct Algo1
{   
    boost::detail::spinlock mSpreadLock;

    Algo1() : mSpreadLock() {}

    //called from thread 1 
    inline void operator()(const indata &signal) 
    {
        if ( signal.action() == SEND )
        {
            double entryadd;
            mSpreadLock.lock();
            entryadd = mSpread * ENTRY_MULTIPLIER; //isnt it possible for compiler to optimize this before the lock? 
            mSpreadLock.unlock();
            FunctionCall(entryadd);
        }
    }

    //called from thread2
    inline void operator()(const indata2 &bospread) 
    {
        boost::detail::spinlock::scoped_lock mylock(mSpreadLock);
        mSpread = bospread.spread();
    }
}

这个呢？

{
    mSpreadLock.lock();
    double entryadd = mSpread * ENTRY_MULTIPLIER; 
    mSpreadLock.unlock();
{

entryadd me 的定义会移到函数顶部吗？

除非我遗漏了什么.. 似乎代码块内的锁定和解锁不起作用。必须使用 scoped_lock。 boost::detail::spinlock::scoped_lock mylock(mSpreadLock) ，它将在函数调用期间锁定。

当然我可以像这样破解它:(但效率较低)

inline void operator()(const indata &signal) 
{
    if ( signal.action() == SEND )
    {
        double entryadd;
        {
            boost::detail::spinlock::scoped_lock mylock(mSpreadLock);
            entryadd = mSpread * ENTRY_MULTIPLIER; 
        }
        FunctionCall(entryadd);
    }
}

Answer 1

锁定操作最终将使用编译器内置函数来执行某种类型的原子操作。编译器知道这些操作不能重新排序，也不会优化“过去”它们。一切都很好。