1

在下面的代码中,事件可能会抛出异常并且它可能不会在偶数处理程序中处理,(罕见但仍然如此)

我希望在执行事件时保持“lck2”解锁,因为我不希望“mtx2”的主线程阻塞,原因无非是优化。

我可以保证“lck2”总是在 catch 块中释放吗?或者可能存在运行时异常,因此可能导致死锁或一些意外行为?

std::unique_lock<std::mutex>lck2(mtx2); // lock used for waiting for event.

while (_isRunning) 
{
    try
    {
        while (_isRunning)
        {
            // cvar2 is condition variable
            cvar2.wait(lck2, [&] {return invoke; }); // wait until invoke == true

            if (invoke) // if event must be invoked
            {
                lck2.unlock();
                OnEvent(this, someproperty); // may throw exception
                lck2.lock();

                invoke = false; // execution completed
            }
        }
    }
    catch (...) // we need to keep this thread alive at all costs!
    {            
        lck2.lock(); // is this safe?
        invoke = false;
    }
}
4

1 回答 1

1

重写您的代码可能更合适,以使其他开发人员更容易处理代码。我将向您展示两个重写:

  • 一、(坏)

    while (true)
    {
        try
        {
            {
                 std::lock_guard<std::mutex> lckx(mtx2);
                 if(!_isRunning)
                       break;    //out of the main loop
            }
    
            bool should_invoke = false;
            {
                    std::unique_lock<std::mutex> lck2(mtx2);
                    cvar2.wait(lck2, [&] {return invoke; });
                    should_invoke = invoke;
            }     
    
            if (should_invoke) // if event must be invoked
            {
                OnEvent(this, someproperty); // may throw exception
                {
                    std::lock_guard<std:mutex> lckx(mtx2);
                    invoke = false; // execution completed
                }
            }
        }
        catch (...) // we need to keep this thread alive at all costs!
        {            
            std::lock_guard<std:mutex> lckx(mtx2);
            invoke = false;
        }
    }
    

  • 二、(好)

    将(第一个)代码分解成更小的功能单元;我们还注意到,表达式cvar2.wait(lck2, [&]{ return invoke; })将暂停执行,只有在被唤醒并且 invokeis时才返回true,那么我们可以推断我们只需要该表达式等待。因此我们可以摒弃invoke. 因此我们有:

    void do_work(){
        while(is_running()){
            try{
                 wait_for_invocation();
                 OnEvent(this, someproperty); // may throw exception
                 set_invocation_state(false);
            catch(...){
                 set_invocation_state(false);
            }
        }
    }
    

    定义助手的位置:

    bool is_running(){
        std::lock_guard<std::mutex> lckx(mtx2);
        return _isRunning;
    }
    
    void wait_for_invocation(){
        std::unique_lock<std::mutex> lck2(mtx2);
        cvar2.wait(lck2, [&] {return invoke; });
    }
    
    void set_invocation_state(bool state){
        std::lock_guard<std::mutex> lckx(mtx2);
        invoke = state;
    }
    
于 2017-07-26T09:54:38.813 回答