读取互斥对象范围之外的volatile变量，而不是std::atomic

我正在尝试优化SPSC队列中的消费者延迟，如下所示：

template <typename TYPE>
class queue
{
public:
void produce(message m)
{
const auto lock = std::scoped_lock(mutex);
has_new_messages = true;
new_messages.emplace_back(std::move(m));
}
void consume()
{
if (UNLIKELY(has_new_messages))
{
const auto lock = std::scoped_lock(mutex);
has_new_messages = false;
messages_to_process.insert(
messages_to_process.cend(),
std::make_move_iterator(new_messages.begin()),
std::make_move_iterator(new_messages.end()));
new_messages.clear();
}
// handle messages_to_process, and then...
messages_to_process.clear();
}
private:
TYPE has_new_messages{false};
std::vector<message> new_messages{};
std::vector<message> messages_to_process{};
std::mutex mutex;
};

如果可能的话，这里的使用者试图避免为互斥锁的锁定/解锁付费，并在锁定互斥锁之前进行检查。

问题是：我是否绝对必须使用TYPE = std::atomic<bool>，或者我可以节省原子操作，并且读取volatile bool就可以了？

众所周知，volatile变量本身并不能保证线程安全，然而，std::mutex::lock()和std::mutex::unlock()提供了一些内存排序保证。我是否可以依靠它们对volatile bool has_new_messages进行更改，以便最终在mutex作用域之外的使用者线程可见？

更新：根据@Peter Cordes的建议，我将重写如下：

void produce(message m)
{
{
const auto lock = std::scoped_lock(mutex);
new_messages.emplace_back(std::move(m));
}
has_new_messages.store(true, std::memory_order_release);
}
void consume()
{
if (UNLIKELY(has_new_messages.exchange(false, std::memory_order_acq_rel))
{
const auto lock = std::scoped_lock(mutex);
messages_to_process.insert(...);
new_messages.clear();
}
}