Question

我想了解有关多线程编程的更多信息，并且我认为尝试在C ++中实现某些C＃同步原语是一个很好的练习。
我从ManualResetEvent开始，这就是到目前为止：

class manual_reset_event
{
public:
    void wait_one()
    {
        if (cv_flag_.load() == false)
        {
            thread_local std::mutex mutex;
            std::unique_lock<std::mutex> lock(mutex);
            cond_var_.wait(lock, [this]() { return cv_flag_.load(); });
        }
    }

    void set()
    {
        cv_flag_.store(true);
        cond_var_.notify_all();
    }

    void reset()
    {
        cv_flag_.store(false);
    }

private:
    std::condition_variable cond_var_;
    std::atomic<bool> cv_flag_;
};

但是，这里有一个竞争条件：您可以在一个线程上调用wait_one（），通过if（cv_flag）检查，然后从另一个线程调用set。即使cv_flag_现在为true，这也会导致wait_one（）等待。
我可以通过在wait_one上使用锁，设置并重置来解决此问题。
我想我也可以通过在cond_var_.wait（）之后在wait_one（）上立即调用cond_var_.notify_all（）来解决此问题，但我认为这不是一个好主意（尽管也许我错了）。
我想知道是否还有其他方法（甚至可能是完全不使用conditional_variables的方法）来避免这种竞争情况。

Answer 1

在大多数情况下，仅对互斥对象使用内部对象的命令并忽略原子是最简单的。只要确保对您的数据的所有访问都受到锁的保护即可。

如果仅存储单个位，则随后快速进行set和reset时可能会导致唤醒丢失，因为仅在reset之后才调度线程等待完成了。要解决该问题，我将使用一个计数器。计数器的最低位是其“打开”状态。此状态的每次更改都以增量实现。我使用64位计数器以防万一。即使32位在长时间运行的程序中可能会回绕，也不太可能。

class manual_reset_event
{
public:
    void wait_one()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        uint64_t initial_value = value_;
        if(initial_value & 1)
        {
            return;
        }
        while (value_ == initial_value)
        {
            signalled_.wait(lock);
        }
    }

    void set()
    {
        std::unique_lock<std::mutex> lock(mutex);
        if((value_ & 1) == 0)
        {
            value_++;
            lock.release(); // optimization
            signalled_.notify_all();
        }
    }

    void reset()
    {
        std::unique_lock<std::mutex> lock(mutex);
        if(value_ & 1)
        {
            value_++;
        }
    }

private:
    std::mutex mutex_;
    std::condition_variable signalled_;
    uint64_t value_;
};

如果您坚持要避免不必要的锁使用，则可以使用原子，但是解决方案有些棘手，因为要考虑的顺序更多。

class manual_reset_event
{
public:
    void wait_one()
    {
        uint64_t initial_value = value_;
        if(initial_value & 1)
        {
            return;
        }
        std::unique_lock<std::mutex> lock(mutex_);
        while (value_ == initial_value)
        { // !
            signalled_.wait(lock);
        }
    }

    void set()
    {
        uint64_t initial_value = value_;
        if(initial_value & 1)
        {
            return;
        }
        std::unique_lock<std::mutex> lock(mutex_);
        // Still need lock to prevent lost wakeup if atomic change happens when
        // other thread is on "// !" line.
        if(value.compare_exchange_strong(initial_value, initial_value + 1)) {
        // One strong attempt is enough. If it fails than someone else must have
        // succeeded. It's as if these two set() operations happened at the same time.
            lock.release();
            signalled_.notify_all();
        }
    }

    void reset()
    {
        uint64_t initial_value = value_;
        if((initial_value & 1) == 0)
        {
            return;
        }
        std::unique_lock<std::mutex> lock(mutex_);
        value.compare_exchange_strong(initial_value, initial_value + 1);
    }

private:
    std::mutex mutex_;
    std::condition_variable signalled_;
    std::atomic<uint64_t> value_;
};

Answer 2

一个可能的实现-保存等待事件线程的列表。可以使用manual_reset_event来保护std::mutex的状态。当线程开始等待时-他检查事件的状态，如果没有发出信号-在列表中插入自己的“等待块”。这是在受公共对象互斥锁保护的“关键部分”内完成的。那么如果我们需要等待事件（仅当我们将自身插入到等待列表中时）-在wait块上开始等待。但在此之前从“关键区域”退出非常重要，甚至在等待之后暂时不要获取。从另一侧看，设置事件的线程-获取已等待线程的列表，然后通知所有事件（从关键部分退出后），或者可能仅通知单个线程，后者首先开始等待。因此，我们可以实现手动重发事件逻辑（当所有等待线程立即唤醒时）或自动重置事件逻辑-当仅唤醒单个线程，并且事件将再次被重置时（根本不设置为信号状态）。仅当没有更多等待的线程时，才会发出事件信号。

class manual_reset_event : std::mutex
{
    struct WaitBlock : public std::condition_variable, std::mutex  
    {
        WaitBlock(WaitBlock* next) : next(next), signaled(false) {}

        WaitBlock* next;
        volatile bool signaled;

        void Wait()
        {
            // synchronization point with Wake()
            std::unique_lock<std::mutex> lock(*this);

            while (!signaled)
            {
                // notify_one() yet not called
                wait(lock);
            }
        }

        void Wake()
        {
            {
                // synchronization point with Wait()
                std::lock_guard<std::mutex> lock(*this);
                signaled = true;
            }
            notify_one();
        }
    };

    WaitBlock* _head;
    volatile bool _signaled;

public:

    manual_reset_event(bool signaled = false) : _signaled(signaled), _head(0) { }

    void wait()
    {
        lock();//++ protect object state

        WaitBlock wb(_head);

        bool inserted = false;

        if (!_signaled)
        {
            _head = &wb;
            inserted = true;
        }

        unlock();//-- protect object state

        if (inserted)
        {
            wb.Wait();
        }
    }

    // manual reset logic
    void set_all() 
    {
        WaitBlock* last, *head = 0;

        lock();//++ protect object state
        head = _head, _signaled = true;
        unlock();//-- protect object state

        while (last = head)
        {
            head = head->next;
            last->Wake();
        }
    }

    // auto reset logic - only one thread will be signaled, event auto reset
    void set_single()  
    {
        WaitBlock* last = 0;

        lock();//++ protect object state

        if (!_signaled)
        {
            if (last = _head)
            {
                // wake first waiting thread

                WaitBlock* prev = 0, *pwb;

                while (pwb = last->next)
                {
                    prev = last, last = pwb;
                }

                (prev ? prev->next : _head) = 0;

            }
            else
            {
                // nobody wait
                _signaled = true;
            }
        }
        unlock();//-- protect object state

        if (last)
        {
            last->Wake();
        }
    }

    void reset()
    {
        _signaled = false;
    }
};

在C ++上的ManualResetEvent（来自C＃）实现：如何避免竞争情况

2 个答案: