C++ 阻塞队列'；s QWaitCondition:在线程仍在等待时销毁

我已经在Qt中构建了自己的阻塞队列，现在有点问题。如果不关闭队列，则在控制台中会出现错误“

QWaitCondition:在线程仍在等待时销毁”

。另一方面，在关闭队列后，我会得到一个访问冲突异常（不管它是在构造函数中还是来自另一个线程）。该异常发生在等待条件的等待方法中

这是我的阻塞队列：

#ifndef BLOCKING_QUEUE_H
#define BLOCKING_QUEUE_H

#include <QObject>
#include <QSharedPointer>
#include <QWaitCondition>
#include <QMutex>
#include <queue>

namespace Concurrency
{
    template<typename Data>
    class BlockingQueue
    {
    private:
        QMutex _mutex;
        QWaitCondition _monitor;
        volatile bool _closed;
        std::queue<QSharedPointer<Data>> _queue;

    public:
        BlockingQueue()
        {
            _closed = false;
        }

        ~BlockingQueue()
        {
            Close(); // When this is enabled, I get an access violation exception in TryDequeue
        }

        void Close()
        {
            QMutexLocker locker(&_mutex);
            if(!_closed)
            {
                _closed = true;
                _queue.empty();
                _monitor.wakeAll();
            }
        }

        bool Enqueue(QSharedPointer<Data> data)
        {
            QMutexLocker locker(&_mutex);

            // Make sure that the queue is not closed
            if(_closed)
            {
                return false;
            }

            _queue.push(data);

            // Signal all the waiting threads
            if(_queue.size()==1)
            {
                _monitor.wakeAll();
            }

            return true;
        }

        bool TryDequeue(QSharedPointer<Data>& value, unsigned long time = ULONG_MAX)
        {
            QMutexLocker locker(&_mutex);

            // Block until something goes into the queue
            // or until the queue is closed
            while(_queue.empty())
            {
                if(_closed || !_monitor.wait(&_mutex, time)) // <-- Access violation if I call close in the destructor
                {
                    return false;
                }
            }

            // Dequeue the next item from the queue
            value = _queue.front();
            _queue.pop();
            return true;
        }
    };
}
#endif BLOCKING_QUEUE_H

\ifndef阻塞队列\u H
#定义阻塞队列
#包括
#包括
#包括
#包括
#包括
命名空间并发
{
模板
类阻塞队列
{
私人：
QMutex_互斥体；
QWAIT状态监视器；
易失性bool\u关闭；
std:：queue\u queue；
公众：
阻塞队列（）
{
_关闭=错误；
}
~BlockingQueue（）
{
Close（）；//启用此选项后，我在TryDequeue中获得一个访问冲突异常
}
无效关闭（）
{
QMutexLocker锁柜（&_互斥锁）；
如果（！\u关闭）
{
_关闭=真；
_queue.empty（）；
_monitor.wakeAll（）；
}
}
布尔排队（QSharedPointer数据）
{
QMutexLocker锁柜（&_互斥锁）；
//确保队列未关闭
如果（_关闭）
{
返回false；
}
_队列推送（数据）；
//给所有等待的线程发信号
如果（_queue.size（）==1）
{
_monitor.wakeAll（）；
}
返回true；
}
bool TryDequeue（QSharedPointer&value，无符号长时间=ULONG_MAX）
{
QMutexLocker锁柜（&_互斥锁）；
//阻塞，直到有东西进入队列
//或者直到队列关闭
while（_queue.empty（））
{
如果（_closed | |！_monitor.wait（&_mutex，time））/我遇到的问题与线程方法有关，有关更多信息，请查看此问题：

使用
BlockingQueue
的服务未正确关闭正在队列上等待的线程，因此，当线程仍在
TryDequeue
方法中等待时，该服务导致队列被破坏