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

#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;
}

    
    void f1(node* ptr) {
        std::unique_ptr<node> q(ptr);
        tail->next = std::move(q);
    }
 
    void f2(const T new_value) {
        tail->data = std::make_shared<T>(std::move(new_value));
    }

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(); // убрали
}

std::lock_guard<std::mutex> lg_tail(m_tail);
tail->data = ..

auto theMax = data[0];
std::mutex m1;
 
#pragma omp parallel for
for (int i = 0; i < count; ++i) {
 if (data[i] > theMax) {
  std::lock_guard<std::mutex> lock(m1);
  if (data[i] > theMax) 
   theMax = data[i];
 } 
}

#include <memory>
#include <atomic>
#include <thread>
 
// clang -std=c++2a -m64 -o lock_free_stack.exe lock_free_stack.cpp
 
using namespace std;
 
template<typename T> class lock_free_stack {
private:
    struct node;
    struct counted_node_ptr {
        int external_count;
        node* ptr;
    };
    struct node {
        shared_ptr<T> data;
        atomic<int> internal_count;
        counted_node_ptr next;
        node(T const& data_): data(make_shared<T>(data_)), internal_count(0) {}
    };
 
    atomic<counted_node_ptr> head;
 
    void increase_head_count(counted_node_ptr& old_counter) {
        counted_node_ptr new_counter;
        do {
            new_counter = old_counter;
            ++new_counter.external_count;
        }
        while(!head.compare_exchange_strong(old_counter, new_counter, 
            memory_order_acquire, 
            memory_order_relaxed));
        old_counter.external_count = new_counter.external_count;
    }
 
public:
    ~lock_free_stack() {
        while(pop());
    }
 
    void push(T const& data) {
        counted_node_ptr new_node;
        new_node.ptr = new node(data);
        new_node.external_count = 1;
        new_node.ptr->next = head.load(memory_order_relaxed);
        while(!head.compare_exchange_weak(new_node.ptr->next, new_node, 
            memory_order_release, 
            memory_order_relaxed));
    }
 
    shared_ptr<T> pop() {
        counted_node_ptr old_head = head.load(memory_order_relaxed);
        for(;;) {
            increase_head_count(old_head);
            node* const ptr = old_head.ptr;
            if(!ptr) {
                return shared_ptr<T>();
            }
            if(head.compare_exchange_strong(old_head, ptr->next, memory_order_relaxed)) {
                shared_ptr<T> res;
                res.swap(ptr->data);
                int const count_increase = old_head.external_count-2;
                if(ptr->internal_count.fetch_add(count_increase, memory_order_release) == -count_increase) {
                    delete ptr;
                }
                return res;
            }
            else if(ptr->internal_count.fetch_add(-1, memory_order_relaxed) == 1) {
                (void)ptr->internal_count.load(memory_order_acquire);
                delete ptr;
            }
        }
    }
};
 
int main() {
    lock_free_stack<int> s;
    s.push(1);
    s.push(2);
    (void)s.pop();
    return 0;
}

#pragma omp parallel for // default = static
for (int i = 0; i < 100; ++i)