Вопрос по многопоточности

#include <iostream>
#include <fstream>
#include <ios>
#include <string>
#include <numeric>
#include <map>
#include <vector>
#include <queue>
#include <iterator>
#include <memory>
#include <mutex>
#include <type_traits>
#include <algorithm>
#include <atomic>
#include <thread>
#include <chrono>
#include <cassert>
 
// clang -std=c++2a -m64 -o thread_safe_queue.exe thread_safe_queue.cpp
 
template<typename T> class thread_safe_queue {
private:
    struct node {
        std::shared_ptr<T> data;
        std::unique_ptr<node> next;
    };
    std::unique_ptr<node> head;
    node* tail;
 
    mutable std::mutex m_head;
    mutable std::mutex m_tail;
 
public:
    thread_safe_queue(const thread_safe_queue& ) = delete;
    thread_safe_queue() : head(new node()), tail(head.get()) {}
 
    node* get_tail() const {
        std::lock_guard<std::mutex> lg_tail(m_tail);
        return tail;
    }
 
    bool empty() const {
        std::lock_guard<std::mutex> lg_head(m_head);
        std::lock_guard<std::mutex> lg_tail(m_tail);
        return (head.get() == tail);
    }
 
    std::shared_ptr<T> pop() {
        std::lock_guard<std::mutex> lg_head(m_head);
        if (head.get() == get_tail()) { // why ?
            return std::shared_ptr<T>();
        }
 
        std::shared_ptr<T> res(head->data);
        std::unique_ptr<node> old_head = std::move(head);
        head = std::move(old_head->next);
        return res;
    }
 
    void push(const T new_value) {
        std::unique_ptr<node> q(new node);
        std::lock_guard<std::mutex> lg_tail(m_tail);
        tail->data = std::make_shared<T>(std::move(new_value));
        tail->next = std::move(q);
        tail = tail->next.get();
    }
};
 
int main(int argc, char *argv[]) {
    return 0;
}

#include <iostream>
#include <string>
#include <thread>
 
using namespace std;
struct A {
    bool b12; // volatile bool b12; // atomic<bool> b12;
    bool b23; // volatile bool b13; // atomic<bool> b13;
public:
    A() : b12(false), b23(false) { }
 
    void printFirst() {
        cout << "1\n";
        b12 = true;
    }
 
    void printSecond() {
        while (!b12);
        cout << "2\n";
        b23 = true;
    }
 
    void printThird() {
        while (!b23);
        cout << "3\n";
    }
};
 
int main() {
    A a;
    thread t1(&A::printFirst,  &a);
    thread t2(&A::printSecond, &a);
    thread t3(&A::printThird,  &a);
    t1.join();
    t2.join();
    t3.join();
 
    return 0;
}

#pragma omp parallel for

tail->data = std::make_shared<T>(std::move(new_value));
<----  вытеснен здесь
tail->next = std::move(q);
tail = tail->next.get();

 
    std::shared_ptr<T> pop() {
        std::lock_guard<std::mutex> lg_head(m_head);
        if (head.get() == get_tail()) { // считывают tail, UB, если push меняет tail
            return std::shared_ptr<T>();
        }
 
        std::shared_ptr<T> res(head->data);
        std::unique_ptr<node> old_head = std::move(head);
        head = std::move(old_head->next);
        return res;
    }
 
    void push(const T new_value) {
        std::unique_ptr<node> q(new node);
        std::lock_guard<std::mutex> lg_tail(m_tail);
        tail->data = std::make_shared<T>(std::move(new_value)); // проблем нет, нет разыменования или изм. значения
        tail->next = std::move(q); // проблем нет, нет разыменования или изм. значения
        tail = tail->next.get(); // переписывает tail, UB, если pop считывает tail
    }

if (head.get() == get_tail()) 
tail = tail->next.get();

        tail->data = std::make_shared<T>(std::move(new_value)); // проблем нет, нет разыменования или изм. значения
        tail->next = std::move(q); // проблем нет, нет разыменования или изм. значения

if (head.get() == get_tail())  // из метода pop
tail = tail->next.get(); // из метода push

        tail->data = std::make_shared<T>(std::move(new_value)); // проблем нет, нет разыменования или изм. значения
        tail->next = std::move(q); // проблем нет, нет разыменования или изм. значения

auto theMax = data[0];
 
#pragma omp parallel for
for (int i = 0; i < count; ++i) {
 if (data[i] > theMax) {
  Lock();
  if (data[i] > theMax) 
   theMax = data[i];
 } 
}

assert(a == 1);