Question

我有一个简单的类，有一个私有成员，可以通过多线程环境中的get（）和set（）访问（多读者/多写者）。如何锁定Get（），因为它只有一个return语句？

class MyValue
{
  private:
    System::CriticalSection lock;
    int val { 0 };

  public:
    int SetValue(int arg)
    {
        lock.Enter();
        val = arg;
        lock.Leave();
    }

    int GetValue()
    {
        lock.Enter();
        return val;
        //Where should I do lock.Leave()?
    }   
}

Answer 1

不要锁定任何东西。在您的示例中，如果您使您的成员成为std::atomic整数就足够了。

这里你不需要任何其他东西。事实上，由于英特尔架构（强大的内存排序模型），这个std::atomic甚至不会导致任何性能问题。

Answer 2

我不是多线程专家，但我认为以下工作应该有效。

int GetValue()
{
    lock.Enter();
    int ret = val;
    lock.Leave();
    return ret;
}

Answer 3

这是来自hauron的回答的同步对象的演示 - 我想表明，对于构建的构建和破坏开销根本不存在。

在下面的代码中，CCsGrabber是一个类似RAII的类，在构造时进入临界区（由CCritical对象包装），然后在销毁时离开它：

class CCsGrabber {
    class CCritical& m_Cs;
    CCsGrabber();
public:
    CCsGrabber(CCritical& cs);
    ~CCsGrabber();
};

class CCritical {
    CRITICAL_SECTION cs;
public:
    CCritical()       { 
        InitializeCriticalSection(&cs); 
    }
    ~CCritical()      { DeleteCriticalSection(&cs); }
    void Enter()      { EnterCriticalSection(&cs); }
    void Leave()      { LeaveCriticalSection(&cs); }
    void Lock()       { Enter(); }
    void Unlock()     { Leave(); }
};

inline CCsGrabber::CCsGrabber(CCritical& cs)  : m_Cs(cs)   { m_Cs.Enter(); }
inline CCsGrabber::CCsGrabber(CCritical *pcs) : m_Cs(*pcs) { m_Cs.Enter(); }
inline CCsGrabber::~CCsGrabber()                           { m_Cs.Leave(); }

现在，在SerialFunc()中创建了一个全局CCritical对象（cs），以及一个本地CCsGrabber实例（csg）来处理锁定和解锁：

CCritical cs;
DWORD last_tick = 0;

void SerialFunc() {
    CCsGrabber csg(cs);
    last_tick = GetTickCount();
}

int main() {
    SerialFunc();
    std::cout << last_tick << std::endl;
}

以下是main（）与优化的32位构建的解集。（我为整个事情的粘贴而道歉 - 我想证明我没有隐藏任何东西：

int main() {
00401C80  push        ebp  
00401C81  mov         ebp,esp  
00401C83  and         esp,0FFFFFFF8h  
00401C86  push        0FFFFFFFFh  
00401C88  push        41B038h  
00401C8D  mov         eax,dword ptr fs:[00000000h]  
00401C93  push        eax  
00401C94  mov         dword ptr fs:[0],esp  
00401C9B  sub         esp,0Ch  
00401C9E  push        esi  
00401C9F  push        edi  
    SerialFunc();
00401CA0  push        427B78h                          ; pointer to CS object
00401CA5  call        dword ptr ds:[41C00Ch]           ; _RtlEnterCriticalSection@4:
00401CAB  call        dword ptr ds:[41C000h]           ; _GetTickCountStub@0:
00401CB1  push        427B78h                          ; pointer to CS object
00401CB6  mov         dword ptr ds:[00427B74h],eax     ; return value => last_tick
00401CBB  call        dword ptr ds:[41C008h]           ; _RtlLeaveCriticalSection@4: 
    std::cout << last_tick << std::endl;
00401CC1  push        ecx  
00401CC2  call        std::basic_ostream<char,std::char_traits<char> >::operator<< (0401D90h)  
00401CC7  mov         esi,eax  
00401CC9  lea         eax,[esp+0Ch]  
00401CCD  push        eax  
00401CCE  mov         ecx,dword ptr [esi]  
00401CD0  mov         ecx,dword ptr [ecx+4]  
00401CD3  add         ecx,esi  
00401CD5  call        std::ios_base::getloc (0401BD0h)  
00401CDA  push        eax  
00401CDB  mov         dword ptr [esp+20h],0  
00401CE3  call        std::use_facet<std::ctype<char> > (0403E40h)  
00401CE8  mov         dword ptr [esp+20h],0FFFFFFFFh  
00401CF0  add         esp,4  
00401CF3  mov         ecx,dword ptr [esp+0Ch]  
00401CF7  mov         edi,eax  
00401CF9  test        ecx,ecx  
00401CFB  je          main+8Eh (0401D0Eh)  
00401CFD  mov         edx,dword ptr [ecx]  
00401CFF  call        dword ptr [edx+8]  
00401D02  test        eax,eax  
00401D04  je          main+8Eh (0401D0Eh)  
00401D06  mov         edx,dword ptr [eax]  
00401D08  mov         ecx,eax  
00401D0A  push        1  
00401D0C  call        dword ptr [edx]  
00401D0E  mov         eax,dword ptr [edi]  
00401D10  mov         ecx,edi  
00401D12  push        0Ah  
00401D14  mov         eax,dword ptr [eax+20h]  
00401D17  call        eax  
00401D19  movzx       eax,al  
00401D1C  mov         ecx,esi  
00401D1E  push        eax  
00401D1F  call        std::basic_ostream<char,std::char_traits<char> >::put (0404220h)  
00401D24  mov         ecx,esi  
00401D26  call        std::basic_ostream<char,std::char_traits<char> >::flush (0402EB0h)  
}
00401D2B  mov         ecx,dword ptr [esp+14h]  
00401D2F  xor         eax,eax  
00401D31  pop         edi  
00401D32  mov         dword ptr fs:[0],ecx  
00401D39  pop         esi  
00401D3A  mov         esp,ebp  
00401D3C  pop         ebp  
00401D3D  ret

所以我们可以看到SerialFunc（）直接内联到main，在开头的序言之后和cout代码之前 - 并且无处可寻找任何超级对象创建，内存分配或任何东西 - 它只是看起来像进入临界区所需的最小汇编代码量，获取变量中的滴答计数，然后离开临界区。

然后我将SerialFunc()更改为：

void SerialFunc() {
    cs.Enter();
    last_tick = GetTickCount();
    cs.Leave();
}

使用明确放置的cs.Enter()和cs.Leave()，只是为了与RAII版本进行比较。生成的代码结果相同：

    int main() {
00401C80  push        ebp  
00401C81  mov         ebp,esp  
00401C83  and         esp,0FFFFFFF8h  
00401C86  push        0FFFFFFFFh  
00401C88  push        41B038h  
00401C8D  mov         eax,dword ptr fs:[00000000h]  
00401C93  push        eax  
00401C94  mov         dword ptr fs:[0],esp  
00401C9B  sub         esp,0Ch  
00401C9E  push        esi  
00401C9F  push        edi  
        SerialFunc();
00401CA0  push        427B78h  
00401CA5  call        dword ptr ds:[41C00Ch]  
00401CAB  call        dword ptr ds:[41C000h]  
00401CB1  push        427B78h  
00401CB6  mov         dword ptr ds:[00427B74h],eax  
00401CBB  call        dword ptr ds:[41C008h]  
        std::cout << last_tick << std::endl;
00401CC1  push        ecx  
00401CC2  call        std::basic_ostream<char,std::char_traits<char> >::operator<< (0401D90h)  
                         ...

在我看来，SergeyA的答案最适合给定的情况 - 从32位变量同步读取和写入的关键部分过多。但是，如果出现需要关键部分或互斥锁的东西，使用类似RAII的对象来简化代码可能不会产生大量（甚至任何）对象创建开销。

（我使用Visual C ++ 2013编译上面的代码）

Answer 4

考虑在ctor中使用类包装器锁定，并在dtor中解锁。请参阅标准实施：http://en.cppreference.com/w/cpp/thread/unique_lock

这样，在代码中抛出复杂代码或异常的情况下，您就不需要记住解锁，从而改变正常执行。

吸气剂的c ++ criticalsection

4 个答案: