Правильность использования std :: atomic & lt; bool & gt; в сочетании с std :: mutex

Я написал класс очереди с общим приоритетом.
Для подачи сигнала о прекращении подачи данных я использую метод Cancel(), который устанавливает знак done в false, и приложение не может записывать / читать любые данные из очереди. Я не уверен в использовании std::atomic<bool> в комбинации с std::mutex а также std::condition_variable, Я не уверен, что мое решение является поточно-ориентированным или может возникнуть состояние гонки:

Оригинальная версия Enqueue метод это:

std::deque<T> deque;
std::mutex mtx;
std::condition_variable cv;
std::atomic<bool> done;

SharedPriorityQueue() : done(false)
{
}

~SharedPriorityQueue()
{
Cancel();
}

void Enqueue(T item)
{
if (done)
{
return;
}

std::lock_guard<std::mutex> lock(mtx);
deque.push_back(item);
cv.notify_one();
}

Тем не менее, может быть переменной done (атомный бул) отделен от механизма блокировки мьютексом?

Для отмены очереди я использую эту конструкцию:

void Cancel()
{
if (done)
{
return;
}
done = true;

cv.notify_all();
}

Какое лучшее решение дизайнов ниже?

// A)
void Enqueue(T item)
{
if (done)
{
return;
}

{
std::lock_guard<std::mutex> lock(mtx); // lock is released before notify call
deque.push_back(item);
}
cv.notify_one();
}

// B)
void Enqueue(T item)
{
{
std::lock_guard<std::mutex> lock(mtx); // done is atomic bool and protected by the lock along with data (deque)
if (done) // atomic bool
{
return;
}

deque.push_back(item);
}
cv.notify_one();
}

// C)
void Enqueue(T item)
{
{
std::lock_guard<std::mutex> lock(mtx); // done is NOT atomic bool and is protected by the lock along with data (deque)
if (done) // simple bool
{
return;
}

deque.push_back(item);
}
cv.notify_one();
}

Обслуживающий персонал:

bool Dequeue(T& item)
{
std::unique_lock<std::mutex> lock(mtx);
while (!done && deque.empty())
{
cv.wait(lock);
}

if (!deque.empty())
{
item = deque.front();
deque.pop_front();
}

if (done)
{
return false;
}
return true;
}