Question

我有一个非常简单的C ++程序，如下所示。 A，B和C类位于DLL中。当我关闭此应用程序时，有时在条件变量上调用notify_all（）时会崩溃。有人可以给我提示原因吗？

我已经检查了很多关于SO的Q / A，但是没有一个解决了我的问题。我在Windows 7和VS2013上工作。

    class B;

    class C
    {
    public:
        C(const std::weak_ptr<B>& b) : mB(b)
        {
        }
        virtual ~C() 
        {
        }

        void run()
        {
            while (true)
            {
                std::unique_lock<std::mutex> uLock(mMutex);

                // Wait until some event is happening
                mCondition.wait_for(uLock, std::chrono::seconds(300));

                if (!mStop)
                {
                    //do something here
                }
                else
                {
                    return;
                }
            }
        }


        void start()
        {
            mThread = std::thread(&C::run, this);
        }

        void stop()
        {
            mStop = false;
        }

        void notify()
        {
            mCondition.notify_all();
        }

        void join()
        {
            if (mThread.joinable())
            {
                mThread.join();
            }
        }

        private:
            std::atomic<bool> mStop;
            std::condition_variable mCondition;
            std::mutex mMutex;
            std::thread mThread;
            std::weak_ptr<B> mB;
        };


    class B : public std::enable_shared_from_this<B>
    {
    public:
        B() {}
        ~B()
        {
            if (mC)
            {
                mC->stop();
                mC->notify();
                mC->join();
            }
        }

        // basic methods
        void init()
        {
            mC = std::unique_ptr<C>(new C(shared_from_this()));
            mC->start();
        }

    private:
        std::unique_ptr<C> mC;
    };

    class A
    {
    public:
        ~A(){}

        void init() { pImpl->init(); }

        static std::shared_ptr<A> getInstance(){
            static std::shared_ptr<A> instance(new A);
            return instance;
        }

    private:
        A() : pImpl(std::make_shared<B>()){}
        std::shared_ptr<B> pImpl;
    };


    void main()
    {
        std::shared_ptr<A> a = A::getInstance();
        a->init();

        int x;
        std::cin >> x;
    }

编辑1：如果我将代码放在B的析构函数中的另一个函数中（例如clean（）），然后从main（）调用它（使用A中的clean（）方法），则不会崩溃正在发生。

Answer 1

代码缺少条件变量通知，因为：

在stop_ = true期间不保留互斥锁（应为true，而不是false）。 stop_必须在持有互斥锁的同时进行读取和修改，并且不必是原子的。当人们将原子与互斥量和条件变量一起使用时，这是导致种族条件的常见原因。
条件变量等待代码在等待之前不检查条件。

修复：

class B;

class C
{
public:
    C(const std::weak_ptr<B>& b) : mB(b) {}
    ~C() { stop(); }

    void run()
    {
        while (true) {
            std::unique_lock<std::mutex> uLock(mMutex);
            while(!mStop /* && !other_real_condition */)
                mCondition.wait_for(uLock, std::chrono::seconds(300));
            if(mStop)
                return;
            // other_real_condition is true, process it.
        }
    }


    void start()
    {
        mThread = std::thread(&C::run, this);
    }

    void stop()
    {
        {
            std::unique_lock<std::mutex> uLock(mMutex);
            mStop = true;
        }
        mCondition.notify_all();
        if (mThread.joinable())
            mThread.join();
    }

    private:
        bool mStop = false; // <--- do not forget to initialize
        std::condition_variable mCondition;
        std::mutex mMutex;
        std::thread mThread;
        std::weak_ptr<B> mB;
    };


class B : public std::enable_shared_from_this<B>
{
public:

    // basic methods
    void init()
    {
        mC = std::unique_ptr<C>(new C(shared_from_this()));
        mC->start();
    }

private:
    std::unique_ptr<C> mC;
};

如果设置mStop时不按住互斥锁，则会发生以下情况：

| Thread 1              | Thread 2            |
| mStop = true          |                     |
| mCondition.notify_all |                     |
|                       | mMutex.lock         |
|                       | mCondition.wait_for |

在上述线程2中，尽管设置了mStop，但丢失了通知并等待。

在更新共享状态时锁定互斥锁可解决争用条件：

| Thread 1                | Thread 2               |
| mMutex.lock             |                        |
| mStop = true            |                        |
| mCondition.notify_all   |                        |
| mMutex.unlock           |                        |
|                         | mMutex.lock            |
|                         | mStop == true, no wait |

在等待条件变量时，必须在保持互斥锁的同时修改和读取共享状态，否则条件通知将会丢失，并且可能导致死锁（当等待时无超时）。这就是为什么不需要将原子与互斥量和条件变量一起使用的原因，您可以同时使用原子或互斥体和条件变量，而不能同时使用。

Answer 2

这似乎是CRT错误（https://stackoverflow.com/a/50525968/896012）。在新版本的Windows（即Windows 10）上不会发生此问题。要解决Windows 7上的崩溃问题，我只是删除了condition_variable并使用了简单的睡眠，而在退出程序时我只是分离了线程。尽管这不是一个干净的方法，但是我认为这是避免崩溃的唯一方法。如果有人找到更好的答案，请告诉我。

关闭程序时，nofify_all（）崩溃

2 个答案: